protobuf/csharp/ProtocolBuffers/DescriptorProtos/Descriptor.cs

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

using pb = global::Google.ProtocolBuffers;

namespace Google.ProtocolBuffers.DescriptorProtos {

  public sealed class Descriptor {
    private Descriptor() {}
    public static pb::Descriptors.FileDescriptor Descriptor {
        get { return descriptor; }
    }
    private static readonly pb::Descriptors.FileDescriptor descriptor = pb::Descriptors.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, 0x59, 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, 0xd0, 0x3e, 0x00, 0xd8, 0x3e, 0x00, 
        }, new pb::Descriptors.FileDescriptor[] {
        });
    
    public sealed class FileDescriptorProto : pb::GeneratedMessage {
      // Use FileDescriptorProto.newBuilder() to construct.
      private FileDescriptorProto() {}
      
      private static readonly FileDescriptorProto defaultInstance = new FileDescriptorProto();
      public static FileDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public FileDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FileDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FileDescriptorProto_fieldAccessorTable; }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // optional string package = 2;
      private bool hasPackage;
      private string package_ = "";
      public boolean HasPackage {
        get { return hasPackage; }
      }
      public string Package {
        get { return package_; }
      }
      
      // repeated string dependency = 3;
      private java.util.List<string> dependency_ =
        java.util.Collections.emptyList();
      public java.util.List<string> getDependencyList() {
        return dependency_;
      }
      public int getDependencyCount() { return dependency_.size(); }
      public string getDependency(int index) {
        return dependency_.get(index);
      }
      
      // repeated .google.protobuf.DescriptorProto message_type = 4;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> EmptyMessageType =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> messageType_ = EmptyMessageType;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> MessageTypeList {
        get { return messageType_; } 
      }
      public int MessageTypeCount { get { return messageType_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto MessageType(int index) {
        return messageType_ [index];
      }
      
      // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> EmptyEnumType =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> enumType_ = EmptyEnumType;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> EnumTypeList {
        get { return enumType_; } 
      }
      public int EnumTypeCount { get { return enumType_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto EnumType(int index) {
        return enumType_ [index];
      }
      
      // repeated .google.protobuf.ServiceDescriptorProto service = 6;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto> EmptyService =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto> service_ = EmptyService;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto> ServiceList {
        get { return service_; } 
      }
      public int ServiceCount { get { return service_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto Service(int index) {
        return service_ [index];
      }
      
      // repeated .google.protobuf.FieldDescriptorProto extension = 7;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> EmptyExtension =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> extension_ = EmptyExtension;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> ExtensionList {
        get { return extension_; } 
      }
      public int ExtensionCount { get { return extension_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto Extension(int index) {
        return extension_ [index];
      }
      
      // optional .google.protobuf.FileOptions options = 8;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        if (hasPackage()) {
          output.writeString(2, getPackage());
        }
        for (string element : getDependencyList()) {
          output.writeString(3, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto element in GetMessageTypeList()) {
          output.writeMessage(4, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto element in GetEnumTypeList()) {
          output.writeMessage(5, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto element in GetServiceList()) {
          output.writeMessage(6, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetExtensionList()) {
          output.writeMessage(7, element);
        }
        if (hasOptions()) {
          output.writeMessage(8, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          if (hasPackage()) {
            size += pb::CodedOutputStream
              .computeStringSize(2, getPackage());
          }
          for (string element : getDependencyList()) {
            size += pb::CodedOutputStream
              .computeStringSize(3, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto element in GetMessageTypeList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(4, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto element in GetEnumTypeList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(5, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto element in GetServiceList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(6, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetExtensionList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(7, element);
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(8, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto buildPartial() {
          if (result.dependency_ != java.util.Collections.EMPTY_LIST) {
            result.dependency_ =
              java.util.Collections.unmodifiableList(result.dependency_);
          }
          if (result.messageType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType) {
            result.messageType_ =
              result.messageType_.AsReadOnly ();
          }
          if (result.enumType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
            result.enumType_ =
              result.enumType_.AsReadOnly ();
          }
          if (result.service_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService) {
            result.service_ =
              result.service_.AsReadOnly ();
          }
          if (result.extension_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
            result.extension_ =
              result.extension_.AsReadOnly ();
          }
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (other.hasPackage()) {
            setPackage(other.getPackage());
          }
          if (!other.dependency_.isEmpty()) {
            if (result.dependency_.isEmpty()) {
              result.dependency_ = new java.util.ArrayList<string>();
            }
            result.dependency_.addAll(other.dependency_);
          }
          if (!other.messageType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType) {
            if (result.messageType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType) {
              result.messageType_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
            }
            result.messageType_.AddCollection(other.messageType_);
          }
          if (!other.enumType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
            if (result.enumType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
              result.enumType_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
            }
            result.enumType_.AddCollection(other.enumType_);
          }
          if (!other.service_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService) {
            if (result.service_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService) {
              result.service_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto>();
            }
            result.service_.AddCollection(other.service_);
          }
          if (!other.extension_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
            if (result.extension_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
              result.extension_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
            }
            result.extension_.AddCollection(other.extension_);
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                setPackage(input.readString());
                break;
              }
              case 26: {
                addDependency(input.readString());
                break;
              }
              case 34: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddMessageType(subBuilder.buildPartial());
                break;
              }
              case 42: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddEnumType(subBuilder.buildPartial());
                break;
              }
              case 50: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddService(subBuilder.buildPartial());
                break;
              }
              case 58: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddExtension(subBuilder.buildPartial());
                break;
              }
              case 66: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // optional string package = 2;
        public boolean HasPackage {
          get { return result.HasPackage; }
        }
        public string Package {
          get { return result.Package; }
          set {
            result.hasPackage = true;
            result.package_ = value;
          }
        }
        public Builder ClearPackage() {
          result.hasPackage = false;
          result.package_ = "";
          return this;
        }
        
        // repeated string dependency = 3;
        public java.util.List<string> getDependencyList() {
          return java.util.Collections.unmodifiableList(result.dependency_);
        }
        public int getDependencyCount() {
          return result.getDependencyCount();
        }
        public string getDependency(int index) {
          return result.getDependency(index);
        }
        public Builder setDependency(int index, string value) {
          result.dependency_.set(index, value);
          return this;
        }
        public Builder addDependency(string value) {
          if (result.dependency_.isEmpty()) {
            result.dependency_ = new java.util.ArrayList<string>();
          }
          result.dependency_.add(value);
          return this;
        }
        public Builder addAllDependency(
            java.lang.Iterable<? extends string> values) {
          if (result.dependency_.isEmpty()) {
            result.dependency_ = new java.util.ArrayList<string>();
          }
          super.addAll(values, result.dependency_);
          return this;
        }
        public Builder clearDependency() {
          result.dependency_ = java.util.Collections.emptyList();
          return this;
        }
        
        // repeated .google.protobuf.DescriptorProto message_type = 4;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> GetMessageTypeList() {
          if (result.messageType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType)
            return result.messageType;
          return result.messageType_.AsReadOnly ();
        }
        public int GetMessageTypeCount() {
          return result.GetMessageTypeCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto GetMessageType(int index) {
          return result.GetMessageType(index);
        }
        public Builder SetMessageType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto value) {
          result.messageType_ [index] = value;
          return this;
        }
        public Builder SetMessageType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder builderForValue) {
          result.messageType_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddMessageType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto value) {
          if (result.messageType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType)
            result.messageType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.messageType_.Add(value);
          return this;
        }
        public Builder AddMessageType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder builderForValue) {
          if (result.messageType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType)
            result.messageType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.messageType_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllMessageType<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto {
          if (result.messageType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType)
            result.messageType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.messageType_.AddEnumerable (values);
          return this;
        }
        public Builder ClearMessageType() {
          result.messageType_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyMessageType;
          return this;
        }
        
        // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> GetEnumTypeList() {
          if (result.enumType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            return result.enumType;
          return result.enumType_.AsReadOnly ();
        }
        public int GetEnumTypeCount() {
          return result.GetEnumTypeCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto GetEnumType(int index) {
          return result.GetEnumType(index);
        }
        public Builder SetEnumType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto value) {
          result.enumType_ [index] = value;
          return this;
        }
        public Builder SetEnumType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder builderForValue) {
          result.enumType_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddEnumType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto value) {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.Add(value);
          return this;
        }
        public Builder AddEnumType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder builderForValue) {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllEnumType<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.AddEnumerable (values);
          return this;
        }
        public Builder ClearEnumType() {
          result.enumType_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType;
          return this;
        }
        
        // repeated .google.protobuf.ServiceDescriptorProto service = 6;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto> GetServiceList() {
          if (result.service_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService)
            return result.service;
          return result.service_.AsReadOnly ();
        }
        public int GetServiceCount() {
          return result.GetServiceCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto GetService(int index) {
          return result.GetService(index);
        }
        public Builder SetService(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto value) {
          result.service_ [index] = value;
          return this;
        }
        public Builder SetService(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.Builder builderForValue) {
          result.service_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddService(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto value) {
          if (result.service == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService)
            result.service = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto>();
          result.service_.Add(value);
          return this;
        }
        public Builder AddService(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.Builder builderForValue) {
          if (result.service == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService)
            result.service = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto>();
          result.service_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllService<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto {
          if (result.service == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService)
            result.service = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto>();
          result.service_.AddEnumerable (values);
          return this;
        }
        public Builder ClearService() {
          result.service_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.EmptyService;
          return this;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto extension = 7;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> GetExtensionList() {
          if (result.extension_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            return result.extension;
          return result.extension_.AsReadOnly ();
        }
        public int GetExtensionCount() {
          return result.GetExtensionCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto GetExtension(int index) {
          return result.GetExtension(index);
        }
        public Builder SetExtension(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          result.extension_ [index] = value;
          return this;
        }
        public Builder SetExtension(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          result.extension_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddExtension(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.Add(value);
          return this;
        }
        public Builder AddExtension(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllExtension<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.AddEnumerable (values);
          return this;
        }
        public Builder ClearExtension() {
          result.extension_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension;
          return this;
        }
        
        // optional .google.protobuf.FileOptions options = 8;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class DescriptorProto : pb::GeneratedMessage {
      // Use DescriptorProto.newBuilder() to construct.
      private DescriptorProto() {}
      
      private static readonly DescriptorProto defaultInstance = new DescriptorProto();
      public static DescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public DescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_DescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_DescriptorProto_fieldAccessorTable; }
      }
      
      public sealed class ExtensionRange : pb::GeneratedMessage {
        // Use ExtensionRange.newBuilder() to construct.
        private ExtensionRange() {}
        
        private static readonly ExtensionRange defaultInstance = new ExtensionRange();
        public static ExtensionRange DefaultInstance {
          get { return defaultInstance; }
        }
        
        public ExtensionRange DefaultInstanceForType {
          get { return defaultInstance; }
        }
        
        public static pb::Descriptors.Descriptor Descriptor {
          get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_DescriptorProto_ExtensionRange_descriptor; }
        }
        
        protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
          get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_DescriptorProto_ExtensionRange_fieldAccessorTable; }
        }
        
        // optional int32 start = 1;
        private bool hasStart;
        private int start_ = 0;
        public boolean HasStart {
          get { return hasStart; }
        }
        public int Start {
          get { return start_; }
        }
        
        // optional int32 end = 2;
        private bool hasEnd;
        private int end_ = 0;
        public boolean HasEnd {
          get { return hasEnd; }
        }
        public int End {
          get { return end_; }
        }
        
        public final boolean isInitialized() {
          return true;
        }
        
        public void writeTo(pb::CodedOutputStream output) {
          if (hasStart()) {
            output.writeInt32(1, getStart());
          }
          if (hasEnd()) {
            output.writeInt32(2, getEnd());
          }
          UnknownFields.WriteTo(output);
        }
        
        private int memoizedSerializedSize = -1;
        public int SerializedSize {
          get {
            int size = memoizedSerializedSize;
            if (size != -1) return size;
            
            size = 0;
            if (hasStart()) {
              size += pb::CodedOutputStream
                .computeInt32Size(1, getStart());
            }
            if (hasEnd()) {
              size += pb::CodedOutputStream
                .computeInt32Size(2, getEnd());
            }
            size += UnknownFieldsSerializedSize;
            memoizedSerializedSize = size;
            return size;
          }
        }
        
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(pb::ByteString data) {
          return newBuilder().mergeFrom(data).buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(pb::ByteString data,
            pb::ExtensionRegistry extensionRegistry) {
          return newBuilder().mergeFrom(data, extensionRegistry)
                   .buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(byte[] data) {
          return newBuilder().mergeFrom(data).buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(byte[] data,
            pb::ExtensionRegistry extensionRegistry) {
          return newBuilder().mergeFrom(data, extensionRegistry)
                   .buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(global::System.IO.Stream input) {
          return newBuilder().mergeFrom(input).buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(
            global::System.IO.Stream input,
            pb::ExtensionRegistry extensionRegistry) {
          return newBuilder().mergeFrom(input, extensionRegistry)
                   .buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(pb::CodedInputStream input) {
          return newBuilder().mergeFrom(input).buildParsed();
        }
        public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange parseFrom(pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          return newBuilder().mergeFrom(input, extensionRegistry)
                   .buildParsed();
        }
        
        public static Builder newBuilder() { return new Builder(); }
        public Builder newBuilderForType() { return new Builder(); }
        public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange prototype) {
          return new Builder().mergeFrom(prototype);
        }
        
        public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
          // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.newBuilder()
          private Builder() {}
          
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange();
          
          protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange internalGetResult() {
            return result;
          }
          
          public Builder clear() {
            result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange();
            return this;
          }
          
          public Builder clone() {
            return new Builder().mergeFrom(result);
          }
          
          public pb::Descriptors.Descriptor
              getDescriptorForType() {
            return Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.getDescriptor();
          }
          
          public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange getDefaultInstanceForType() {
            return Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.getDefaultInstance();
          }
          
          public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange build() {
            if (!isInitialized()) {
              throw new pb::UninitializedMessageException(
                result);
            }
            return buildPartial();
          }
          
          private Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange buildParsed() {
            if (!isInitialized()) {
              throw new pb::UninitializedMessageException(
                result).asInvalidProtocolBufferException();
            }
            return buildPartial();
          }
          
          public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange buildPartial() {
            Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange returnMe = result;
            result = null;
            return returnMe;
          }
          
          public Builder mergeFrom(pb::Message other) {
            if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange) {
              return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange)other);
            } else {
              super.mergeFrom(other);
              return this;
            }
          }
          
          public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange other) {
            if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.getDefaultInstance()) return this;
            if (other.hasStart()) {
              setStart(other.getStart());
            }
            if (other.hasEnd()) {
              setEnd(other.getEnd());
            }
            this.mergeUnknownFields(other.getUnknownFields());
            return this;
          }
          
          public Builder mergeFrom(
              pb::CodedInputStream input) {
            return mergeFrom(input,
              pb::ExtensionRegistry.getEmptyRegistry());
          }
          
          public Builder mergeFrom(
              pb::CodedInputStream input,
              pb::ExtensionRegistry extensionRegistry) {
            pb::UnknownFieldSet.Builder unknownFields =
              pb::UnknownFieldSet.newBuilder(
                this.getUnknownFields());
            while (true) {
              int tag = input.readTag();
              switch (tag) {
                case 0:
                  this.setUnknownFields(unknownFields.build());
                  return this;
                default: {
                  if (!parseUnknownField(input, unknownFields,
                                         extensionRegistry, tag)) {
                    this.setUnknownFields(unknownFields.build());
                    return this;
                  }
                  break;
                }
                case 8: {
                  setStart(input.readInt32());
                  break;
                }
                case 16: {
                  setEnd(input.readInt32());
                  break;
                }
              }
            }
          }
          
          
          // optional int32 start = 1;
          public boolean HasStart {
            get { return result.HasStart; }
          }
          public int Start {
            get { return result.Start; }
            set {
              result.hasStart = true;
              result.start_ = value;
            }
          }
          public Builder ClearStart() {
            result.hasStart = false;
            result.start_ = 0;
            return this;
          }
          
          // optional int32 end = 2;
          public boolean HasEnd {
            get { return result.HasEnd; }
          }
          public int End {
            get { return result.End; }
            set {
              result.hasEnd = true;
              result.end_ = value;
            }
          }
          public Builder ClearEnd() {
            result.hasEnd = false;
            result.end_ = 0;
            return this;
          }
        }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // repeated .google.protobuf.FieldDescriptorProto field = 2;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> EmptyField =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> field_ = EmptyField;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> FieldList {
        get { return field_; } 
      }
      public int FieldCount { get { return field_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto Field(int index) {
        return field_ [index];
      }
      
      // repeated .google.protobuf.FieldDescriptorProto extension = 6;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> EmptyExtension =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> extension_ = EmptyExtension;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> ExtensionList {
        get { return extension_; } 
      }
      public int ExtensionCount { get { return extension_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto Extension(int index) {
        return extension_ [index];
      }
      
      // repeated .google.protobuf.DescriptorProto nested_type = 3;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> EmptyNestedType =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> nestedType_ = EmptyNestedType;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> NestedTypeList {
        get { return nestedType_; } 
      }
      public int NestedTypeCount { get { return nestedType_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto NestedType(int index) {
        return nestedType_ [index];
      }
      
      // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> EmptyEnumType =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> enumType_ = EmptyEnumType;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> EnumTypeList {
        get { return enumType_; } 
      }
      public int EnumTypeCount { get { return enumType_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto EnumType(int index) {
        return enumType_ [index];
      }
      
      // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange> EmptyExtensionRange =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange> extensionRange_ = EmptyExtensionRange;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange> ExtensionRangeList {
        get { return extensionRange_; } 
      }
      public int ExtensionRangeCount { get { return extensionRange_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange ExtensionRange(int index) {
        return extensionRange_ [index];
      }
      
      // optional .google.protobuf.MessageOptions options = 7;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetFieldList()) {
          output.writeMessage(2, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto element in GetNestedTypeList()) {
          output.writeMessage(3, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto element in GetEnumTypeList()) {
          output.writeMessage(4, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange element in GetExtensionRangeList()) {
          output.writeMessage(5, element);
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetExtensionList()) {
          output.writeMessage(6, element);
        }
        if (hasOptions()) {
          output.writeMessage(7, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetFieldList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(2, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto element in GetNestedTypeList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(3, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto element in GetEnumTypeList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(4, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange element in GetExtensionRangeList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(5, element);
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto element in GetExtensionList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(6, element);
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(7, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto buildPartial() {
          if (result.field_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField) {
            result.field_ =
              result.field_.AsReadOnly ();
          }
          if (result.extension_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
            result.extension_ =
              result.extension_.AsReadOnly ();
          }
          if (result.nestedType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType) {
            result.nestedType_ =
              result.nestedType_.AsReadOnly ();
          }
          if (result.enumType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
            result.enumType_ =
              result.enumType_.AsReadOnly ();
          }
          if (result.extensionRange_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange) {
            result.extensionRange_ =
              result.extensionRange_.AsReadOnly ();
          }
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (!other.field_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField) {
            if (result.field_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField) {
              result.field_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
            }
            result.field_.AddCollection(other.field_);
          }
          if (!other.extension_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
            if (result.extension_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension) {
              result.extension_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
            }
            result.extension_.AddCollection(other.extension_);
          }
          if (!other.nestedType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType) {
            if (result.nestedType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType) {
              result.nestedType_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
            }
            result.nestedType_.AddCollection(other.nestedType_);
          }
          if (!other.enumType_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
            if (result.enumType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType) {
              result.enumType_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
            }
            result.enumType_.AddCollection(other.enumType_);
          }
          if (!other.extensionRange_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange) {
            if (result.extensionRange_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange) {
              result.extensionRange_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange>();
            }
            result.extensionRange_.AddCollection(other.extensionRange_);
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddField(subBuilder.buildPartial());
                break;
              }
              case 26: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddNestedType(subBuilder.buildPartial());
                break;
              }
              case 34: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddEnumType(subBuilder.buildPartial());
                break;
              }
              case 42: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddExtensionRange(subBuilder.buildPartial());
                break;
              }
              case 50: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddExtension(subBuilder.buildPartial());
                break;
              }
              case 58: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto field = 2;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> GetFieldList() {
          if (result.field_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField)
            return result.field;
          return result.field_.AsReadOnly ();
        }
        public int GetFieldCount() {
          return result.GetFieldCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto GetField(int index) {
          return result.GetField(index);
        }
        public Builder SetField(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          result.field_ [index] = value;
          return this;
        }
        public Builder SetField(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          result.field_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddField(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          if (result.field == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField)
            result.field = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.field_.Add(value);
          return this;
        }
        public Builder AddField(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          if (result.field == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField)
            result.field = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.field_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllField<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto {
          if (result.field == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField)
            result.field = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.field_.AddEnumerable (values);
          return this;
        }
        public Builder ClearField() {
          result.field_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyField;
          return this;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto extension = 6;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto> GetExtensionList() {
          if (result.extension_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            return result.extension;
          return result.extension_.AsReadOnly ();
        }
        public int GetExtensionCount() {
          return result.GetExtensionCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto GetExtension(int index) {
          return result.GetExtension(index);
        }
        public Builder SetExtension(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          result.extension_ [index] = value;
          return this;
        }
        public Builder SetExtension(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          result.extension_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddExtension(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto value) {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.Add(value);
          return this;
        }
        public Builder AddExtension(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder builderForValue) {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllExtension<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto {
          if (result.extension == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension)
            result.extension = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto>();
          result.extension_.AddEnumerable (values);
          return this;
        }
        public Builder ClearExtension() {
          result.extension_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.EmptyExtension;
          return this;
        }
        
        // repeated .google.protobuf.DescriptorProto nested_type = 3;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto> GetNestedTypeList() {
          if (result.nestedType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType)
            return result.nestedType;
          return result.nestedType_.AsReadOnly ();
        }
        public int GetNestedTypeCount() {
          return result.GetNestedTypeCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto GetNestedType(int index) {
          return result.GetNestedType(index);
        }
        public Builder SetNestedType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto value) {
          result.nestedType_ [index] = value;
          return this;
        }
        public Builder SetNestedType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder builderForValue) {
          result.nestedType_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddNestedType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto value) {
          if (result.nestedType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType)
            result.nestedType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.nestedType_.Add(value);
          return this;
        }
        public Builder AddNestedType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder builderForValue) {
          if (result.nestedType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType)
            result.nestedType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.nestedType_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllNestedType<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto {
          if (result.nestedType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType)
            result.nestedType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto>();
          result.nestedType_.AddEnumerable (values);
          return this;
        }
        public Builder ClearNestedType() {
          result.nestedType_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.EmptyNestedType;
          return this;
        }
        
        // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto> GetEnumTypeList() {
          if (result.enumType_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            return result.enumType;
          return result.enumType_.AsReadOnly ();
        }
        public int GetEnumTypeCount() {
          return result.GetEnumTypeCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto GetEnumType(int index) {
          return result.GetEnumType(index);
        }
        public Builder SetEnumType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto value) {
          result.enumType_ [index] = value;
          return this;
        }
        public Builder SetEnumType(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder builderForValue) {
          result.enumType_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddEnumType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto value) {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.Add(value);
          return this;
        }
        public Builder AddEnumType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder builderForValue) {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllEnumType<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto {
          if (result.enumType == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType)
            result.enumType = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto>();
          result.enumType_.AddEnumerable (values);
          return this;
        }
        public Builder ClearEnumType() {
          result.enumType_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.EmptyEnumType;
          return this;
        }
        
        // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange> GetExtensionRangeList() {
          if (result.extensionRange_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange)
            return result.extensionRange;
          return result.extensionRange_.AsReadOnly ();
        }
        public int GetExtensionRangeCount() {
          return result.GetExtensionRangeCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange GetExtensionRange(int index) {
          return result.GetExtensionRange(index);
        }
        public Builder SetExtensionRange(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange value) {
          result.extensionRange_ [index] = value;
          return this;
        }
        public Builder SetExtensionRange(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.Builder builderForValue) {
          result.extensionRange_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddExtensionRange(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange value) {
          if (result.extensionRange == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange)
            result.extensionRange = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange>();
          result.extensionRange_.Add(value);
          return this;
        }
        public Builder AddExtensionRange(Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.Builder builderForValue) {
          if (result.extensionRange == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange)
            result.extensionRange = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange>();
          result.extensionRange_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllExtensionRange<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange {
          if (result.extensionRange == Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange)
            result.extensionRange = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange>();
          result.extensionRange_.AddEnumerable (values);
          return this;
        }
        public Builder ClearExtensionRange() {
          result.extensionRange_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.EmptyExtensionRange;
          return this;
        }
        
        // optional .google.protobuf.MessageOptions options = 7;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class FieldDescriptorProto : pb::GeneratedMessage {
      // Use FieldDescriptorProto.newBuilder() to construct.
      private FieldDescriptorProto() {}
      
      private static readonly FieldDescriptorProto defaultInstance = new FieldDescriptorProto();
      public static FieldDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public FieldDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FieldDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FieldDescriptorProto_fieldAccessorTable; }
      }
      
      public enum Type {
        [pb::DescriptorIndex(0)]
        TYPE_DOUBLE = 1,
        [pb::DescriptorIndex(1)]
        TYPE_FLOAT = 2,
        [pb::DescriptorIndex(2)]
        TYPE_INT64 = 3,
        [pb::DescriptorIndex(3)]
        TYPE_UINT64 = 4,
        [pb::DescriptorIndex(4)]
        TYPE_INT32 = 5,
        [pb::DescriptorIndex(5)]
        TYPE_FIXED64 = 6,
        [pb::DescriptorIndex(6)]
        TYPE_FIXED32 = 7,
        [pb::DescriptorIndex(7)]
        TYPE_BOOL = 8,
        [pb::DescriptorIndex(8)]
        TYPE_STRING = 9,
        [pb::DescriptorIndex(9)]
        TYPE_GROUP = 10,
        [pb::DescriptorIndex(10)]
        TYPE_MESSAGE = 11,
        [pb::DescriptorIndex(11)]
        TYPE_BYTES = 12,
        [pb::DescriptorIndex(12)]
        TYPE_UINT32 = 13,
        [pb::DescriptorIndex(13)]
        TYPE_ENUM = 14,
        [pb::DescriptorIndex(14)]
        TYPE_SFIXED32 = 15,
        [pb::DescriptorIndex(15)]
        TYPE_SFIXED64 = 16,
        [pb::DescriptorIndex(16)]
        TYPE_SINT32 = 17,
        [pb::DescriptorIndex(17)]
        TYPE_SINT64 = 18,
      }
      
      public enum Label {
        [pb::DescriptorIndex(0)]
        LABEL_OPTIONAL = 1,
        [pb::DescriptorIndex(1)]
        LABEL_REQUIRED = 2,
        [pb::DescriptorIndex(2)]
        LABEL_REPEATED = 3,
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // optional int32 number = 3;
      private bool hasNumber;
      private int number_ = 0;
      public boolean HasNumber {
        get { return hasNumber; }
      }
      public int Number {
        get { return number_; }
      }
      
      // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
      private boolean hasLabel;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label label_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label.LABEL_OPTIONAL;
      public boolean HasLabel() { return hasLabel; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label GetLabel() { return label_; }
      
      // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
      private boolean hasType;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type type_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type.TYPE_DOUBLE;
      public boolean HasType() { return hasType; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type GetType() { return type_; }
      
      // optional string type_name = 6;
      private bool hasTypeName;
      private string typeName_ = "";
      public boolean HasTypeName {
        get { return hasTypeName; }
      }
      public string TypeName {
        get { return typeName_; }
      }
      
      // optional string extendee = 2;
      private bool hasExtendee;
      private string extendee_ = "";
      public boolean HasExtendee {
        get { return hasExtendee; }
      }
      public string Extendee {
        get { return extendee_; }
      }
      
      // optional string default_value = 7;
      private bool hasDefaultValue;
      private string defaultValue_ = "";
      public boolean HasDefaultValue {
        get { return hasDefaultValue; }
      }
      public string DefaultValue {
        get { return defaultValue_; }
      }
      
      // optional .google.protobuf.FieldOptions options = 8;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        if (hasExtendee()) {
          output.writeString(2, getExtendee());
        }
        if (hasNumber()) {
          output.writeInt32(3, getNumber());
        }
        if (hasLabel()) {
          output.writeEnum(4, getLabel().getNumber());
        }
        if (hasType()) {
          output.writeEnum(5, getType().getNumber());
        }
        if (hasTypeName()) {
          output.writeString(6, getTypeName());
        }
        if (hasDefaultValue()) {
          output.writeString(7, getDefaultValue());
        }
        if (hasOptions()) {
          output.writeMessage(8, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          if (hasExtendee()) {
            size += pb::CodedOutputStream
              .computeStringSize(2, getExtendee());
          }
          if (hasNumber()) {
            size += pb::CodedOutputStream
              .computeInt32Size(3, getNumber());
          }
          if (hasLabel()) {
            size += pb::CodedOutputStream
              .computeEnumSize(4, getLabel().getNumber());
          }
          if (hasType()) {
            size += pb::CodedOutputStream
              .computeEnumSize(5, getType().getNumber());
          }
          if (hasTypeName()) {
            size += pb::CodedOutputStream
              .computeStringSize(6, getTypeName());
          }
          if (hasDefaultValue()) {
            size += pb::CodedOutputStream
              .computeStringSize(7, getDefaultValue());
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(8, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (other.hasNumber()) {
            setNumber(other.getNumber());
          }
          if (other.hasLabel()) {
            setLabel(other.getLabel());
          }
          if (other.hasType()) {
            setType(other.getType());
          }
          if (other.hasTypeName()) {
            setTypeName(other.getTypeName());
          }
          if (other.hasExtendee()) {
            setExtendee(other.getExtendee());
          }
          if (other.hasDefaultValue()) {
            setDefaultValue(other.getDefaultValue());
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                setExtendee(input.readString());
                break;
              }
              case 24: {
                setNumber(input.readInt32());
                break;
              }
              case 32: {
                int rawValue = input.readEnum();
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label value = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label.valueOf(rawValue);
                if (value == null) {
                  unknownFields.mergeVarintField(4, rawValue);
                } else {
                  setLabel(value);
                }
                break;
              }
              case 40: {
                int rawValue = input.readEnum();
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type value = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type.valueOf(rawValue);
                if (value == null) {
                  unknownFields.mergeVarintField(5, rawValue);
                } else {
                  setType(value);
                }
                break;
              }
              case 50: {
                setTypeName(input.readString());
                break;
              }
              case 58: {
                setDefaultValue(input.readString());
                break;
              }
              case 66: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // optional int32 number = 3;
        public boolean HasNumber {
          get { return result.HasNumber; }
        }
        public int Number {
          get { return result.Number; }
          set {
            result.hasNumber = true;
            result.number_ = value;
          }
        }
        public Builder ClearNumber() {
          result.hasNumber = false;
          result.number_ = 0;
          return this;
        }
        
        // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
        public boolean HasLabel() {
          return result.HasLabel();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label GetLabel() {
          return result.GetLabel();
        }
        public Builder SetLabel(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label value) {
          result.hasLabel = true;
          result.label_ = value;
          return this;
        }
        public Builder ClearLabel() {
          result.hasLabel = false;
          result.label_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Label.LABEL_OPTIONAL;
          return this;
        }
        
        // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
        public boolean HasType() {
          return result.HasType();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type GetType() {
          return result.GetType();
        }
        public Builder SetType(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type value) {
          result.hasType = true;
          result.type_ = value;
          return this;
        }
        public Builder ClearType() {
          result.hasType = false;
          result.type_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Type.TYPE_DOUBLE;
          return this;
        }
        
        // optional string type_name = 6;
        public boolean HasTypeName {
          get { return result.HasTypeName; }
        }
        public string TypeName {
          get { return result.TypeName; }
          set {
            result.hasTypeName = true;
            result.typeName_ = value;
          }
        }
        public Builder ClearTypeName() {
          result.hasTypeName = false;
          result.typeName_ = "";
          return this;
        }
        
        // optional string extendee = 2;
        public boolean HasExtendee {
          get { return result.HasExtendee; }
        }
        public string Extendee {
          get { return result.Extendee; }
          set {
            result.hasExtendee = true;
            result.extendee_ = value;
          }
        }
        public Builder ClearExtendee() {
          result.hasExtendee = false;
          result.extendee_ = "";
          return this;
        }
        
        // optional string default_value = 7;
        public boolean HasDefaultValue {
          get { return result.HasDefaultValue; }
        }
        public string DefaultValue {
          get { return result.DefaultValue; }
          set {
            result.hasDefaultValue = true;
            result.defaultValue_ = value;
          }
        }
        public Builder ClearDefaultValue() {
          result.hasDefaultValue = false;
          result.defaultValue_ = "";
          return this;
        }
        
        // optional .google.protobuf.FieldOptions options = 8;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class EnumDescriptorProto : pb::GeneratedMessage {
      // Use EnumDescriptorProto.newBuilder() to construct.
      private EnumDescriptorProto() {}
      
      private static readonly EnumDescriptorProto defaultInstance = new EnumDescriptorProto();
      public static EnumDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public EnumDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumDescriptorProto_fieldAccessorTable; }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto> EmptyValue =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto> value_ = EmptyValue;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto> ValueList {
        get { return value_; } 
      }
      public int ValueCount { get { return value_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto Value(int index) {
        return value_ [index];
      }
      
      // optional .google.protobuf.EnumOptions options = 3;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto element in GetValueList()) {
          output.writeMessage(2, element);
        }
        if (hasOptions()) {
          output.writeMessage(3, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto element in GetValueList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(2, element);
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(3, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto buildPartial() {
          if (result.value_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue) {
            result.value_ =
              result.value_.AsReadOnly ();
          }
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (!other.value_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue) {
            if (result.value_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue) {
              result.value_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto>();
            }
            result.value_.AddCollection(other.value_);
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddValue(subBuilder.buildPartial());
                break;
              }
              case 26: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto> GetValueList() {
          if (result.value_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue)
            return result.value;
          return result.value_.AsReadOnly ();
        }
        public int GetValueCount() {
          return result.GetValueCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto GetValue(int index) {
          return result.GetValue(index);
        }
        public Builder SetValue(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto value) {
          result.value_ [index] = value;
          return this;
        }
        public Builder SetValue(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.Builder builderForValue) {
          result.value_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddValue(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto value) {
          if (result.value == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue)
            result.value = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto>();
          result.value_.Add(value);
          return this;
        }
        public Builder AddValue(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.Builder builderForValue) {
          if (result.value == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue)
            result.value = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto>();
          result.value_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllValue<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto {
          if (result.value == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue)
            result.value = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto>();
          result.value_.AddEnumerable (values);
          return this;
        }
        public Builder ClearValue() {
          result.value_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.EmptyValue;
          return this;
        }
        
        // optional .google.protobuf.EnumOptions options = 3;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class EnumValueDescriptorProto : pb::GeneratedMessage {
      // Use EnumValueDescriptorProto.newBuilder() to construct.
      private EnumValueDescriptorProto() {}
      
      private static readonly EnumValueDescriptorProto defaultInstance = new EnumValueDescriptorProto();
      public static EnumValueDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public EnumValueDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumValueDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumValueDescriptorProto_fieldAccessorTable; }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // optional int32 number = 2;
      private bool hasNumber;
      private int number_ = 0;
      public boolean HasNumber {
        get { return hasNumber; }
      }
      public int Number {
        get { return number_; }
      }
      
      // optional .google.protobuf.EnumValueOptions options = 3;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        if (hasNumber()) {
          output.writeInt32(2, getNumber());
        }
        if (hasOptions()) {
          output.writeMessage(3, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          if (hasNumber()) {
            size += pb::CodedOutputStream
              .computeInt32Size(2, getNumber());
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(3, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (other.hasNumber()) {
            setNumber(other.getNumber());
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 16: {
                setNumber(input.readInt32());
                break;
              }
              case 26: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // optional int32 number = 2;
        public boolean HasNumber {
          get { return result.HasNumber; }
        }
        public int Number {
          get { return result.Number; }
          set {
            result.hasNumber = true;
            result.number_ = value;
          }
        }
        public Builder ClearNumber() {
          result.hasNumber = false;
          result.number_ = 0;
          return this;
        }
        
        // optional .google.protobuf.EnumValueOptions options = 3;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class ServiceDescriptorProto : pb::GeneratedMessage {
      // Use ServiceDescriptorProto.newBuilder() to construct.
      private ServiceDescriptorProto() {}
      
      private static readonly ServiceDescriptorProto defaultInstance = new ServiceDescriptorProto();
      public static ServiceDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public ServiceDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_ServiceDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_ServiceDescriptorProto_fieldAccessorTable; }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // repeated .google.protobuf.MethodDescriptorProto method = 2;
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto> EmptyMethod =
        new System.Collections.ReadOnlyCollection<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto> ();
      internal System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto> method_ = EmptyMethod;
      public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto> MethodList {
        get { return method_; } 
      }
      public int MethodCount { get { return method_.Count; }  }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto Method(int index) {
        return method_ [index];
      }
      
      // optional .google.protobuf.ServiceOptions options = 3;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto element in GetMethodList()) {
          output.writeMessage(2, element);
        }
        if (hasOptions()) {
          output.writeMessage(3, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          foreach (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto element in GetMethodList()) {
            size += pb::CodedOutputStream
              .computeMessageSize(2, element);
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(3, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto buildPartial() {
          if (result.method_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod) {
            result.method_ =
              result.method_.AsReadOnly ();
          }
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (!other.method_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod) {
            if (result.method_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod) {
              result.method_ = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto>();
            }
            result.method_.AddCollection(other.method_);
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.newBuilder();
                input.readMessage(subBuilder, extensionRegistry);
                AddMethod(subBuilder.buildPartial());
                break;
              }
              case 26: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // repeated .google.protobuf.MethodDescriptorProto method = 2;
        public System.Collections.Generic.IList<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto> GetMethodList() {
          if (result.method_ == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod)
            return result.method;
          return result.method_.AsReadOnly ();
        }
        public int GetMethodCount() {
          return result.GetMethodCount();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto GetMethod(int index) {
          return result.GetMethod(index);
        }
        public Builder SetMethod(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto value) {
          result.method_ [index] = value;
          return this;
        }
        public Builder SetMethod(int index, Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.Builder builderForValue) {
          result.method_ [index] = builderForValue.build();
          return this;
        }
        public Builder AddMethod(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto value) {
          if (result.method == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod)
            result.method = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto>();
          result.method_.Add(value);
          return this;
        }
        public Builder AddMethod(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.Builder builderForValue) {
          if (result.method == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod)
            result.method = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto>();
          result.method_.Add(builderForValue.build());
          return this;
        }
        public Builder AddAllMethod<T>(
            global::System.Collections.Generic.IEnumerable<T> values) where T : Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto {
          if (result.method == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod)
            result.method = new System.Collections.Generic.List<Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto>();
          result.method_.AddEnumerable (values);
          return this;
        }
        public Builder ClearMethod() {
          result.method_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.EmptyMethod;
          return this;
        }
        
        // optional .google.protobuf.ServiceOptions options = 3;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class MethodDescriptorProto : pb::GeneratedMessage {
      // Use MethodDescriptorProto.newBuilder() to construct.
      private MethodDescriptorProto() {}
      
      private static readonly MethodDescriptorProto defaultInstance = new MethodDescriptorProto();
      public static MethodDescriptorProto DefaultInstance {
        get { return defaultInstance; }
      }
      
      public MethodDescriptorProto DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MethodDescriptorProto_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MethodDescriptorProto_fieldAccessorTable; }
      }
      
      // optional string name = 1;
      private bool hasName;
      private string name_ = "";
      public boolean HasName {
        get { return hasName; }
      }
      public string Name {
        get { return name_; }
      }
      
      // optional string input_type = 2;
      private bool hasInputType;
      private string inputType_ = "";
      public boolean HasInputType {
        get { return hasInputType; }
      }
      public string InputType {
        get { return inputType_; }
      }
      
      // optional string output_type = 3;
      private bool hasOutputType;
      private string outputType_ = "";
      public boolean HasOutputType {
        get { return hasOutputType; }
      }
      public string OutputType {
        get { return outputType_; }
      }
      
      // optional .google.protobuf.MethodOptions options = 4;
      private boolean hasOptions;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDefaultInstance();
      public boolean hasOptions() { return hasOptions; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions getOptions() { return options_; }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasName()) {
          output.writeString(1, getName());
        }
        if (hasInputType()) {
          output.writeString(2, getInputType());
        }
        if (hasOutputType()) {
          output.writeString(3, getOutputType());
        }
        if (hasOptions()) {
          output.writeMessage(4, getOptions());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasName()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getName());
          }
          if (hasInputType()) {
            size += pb::CodedOutputStream
              .computeStringSize(2, getInputType());
          }
          if (hasOutputType()) {
            size += pb::CodedOutputStream
              .computeStringSize(3, getOutputType());
          }
          if (hasOptions()) {
            size += pb::CodedOutputStream
              .computeMessageSize(4, getOptions());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.getDefaultInstance()) return this;
          if (other.hasName()) {
            setName(other.getName());
          }
          if (other.hasInputType()) {
            setInputType(other.getInputType());
          }
          if (other.hasOutputType()) {
            setOutputType(other.getOutputType());
          }
          if (other.hasOptions()) {
            mergeOptions(other.getOptions());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setName(input.readString());
                break;
              }
              case 18: {
                setInputType(input.readString());
                break;
              }
              case 26: {
                setOutputType(input.readString());
                break;
              }
              case 34: {
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.Builder subBuilder = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.newBuilder();
                if (hasOptions()) {
                  subBuilder.mergeFrom(getOptions());
                }
                input.readMessage(subBuilder, extensionRegistry);
                setOptions(subBuilder.buildPartial());
                break;
              }
            }
          }
        }
        
        
        // optional string name = 1;
        public boolean HasName {
          get { return result.HasName; }
        }
        public string Name {
          get { return result.Name; }
          set {
            result.hasName = true;
            result.name_ = value;
          }
        }
        public Builder ClearName() {
          result.hasName = false;
          result.name_ = "";
          return this;
        }
        
        // optional string input_type = 2;
        public boolean HasInputType {
          get { return result.HasInputType; }
        }
        public string InputType {
          get { return result.InputType; }
          set {
            result.hasInputType = true;
            result.inputType_ = value;
          }
        }
        public Builder ClearInputType() {
          result.hasInputType = false;
          result.inputType_ = "";
          return this;
        }
        
        // optional string output_type = 3;
        public boolean HasOutputType {
          get { return result.HasOutputType; }
        }
        public string OutputType {
          get { return result.OutputType; }
          set {
            result.hasOutputType = true;
            result.outputType_ = value;
          }
        }
        public Builder ClearOutputType() {
          result.hasOutputType = false;
          result.outputType_ = "";
          return this;
        }
        
        // optional .google.protobuf.MethodOptions options = 4;
        public boolean hasOptions() {
          return result.hasOptions();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions getOptions() {
          return result.getOptions();
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions value) {
          result.hasOptions = true;
          result.options_ = value;
          return this;
        }
        public Builder setOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.Builder builderForValue) {
          result.hasOptions = true;
          result.options_ = builderForValue.build();
          return this;
        }
        public Builder mergeOptions(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions value) {
          if (result.hasOptions() &&
              result.options_ != Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDefaultInstance()) {
            result.options_ =
              Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.newBuilder(result.options_).mergeFrom(value).buildPartial();
          } else {
            result.options_ = value;
          }
          result.hasOptions = true;
          return this;
        }
        public Builder clearOptions() {
          result.hasOptions = false;
          result.options_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDefaultInstance();
          return this;
        }
      }
    }
    
    public sealed class FileOptions : pb::GeneratedMessage {
      // Use FileOptions.newBuilder() to construct.
      private FileOptions() {}
      
      private static readonly FileOptions defaultInstance = new FileOptions();
      public static FileOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public FileOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FileOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FileOptions_fieldAccessorTable; }
      }
      
      public enum OptimizeMode {
        [pb::DescriptorIndex(0)]
        SPEED = 1,
        [pb::DescriptorIndex(1)]
        CODE_SIZE = 2,
      }
      
      // optional string java_package = 1;
      private bool hasJavaPackage;
      private string javaPackage_ = "";
      public boolean HasJavaPackage {
        get { return hasJavaPackage; }
      }
      public string JavaPackage {
        get { return javaPackage_; }
      }
      
      // optional string java_outer_classname = 8;
      private bool hasJavaOuterClassname;
      private string javaOuterClassname_ = "";
      public boolean HasJavaOuterClassname {
        get { return hasJavaOuterClassname; }
      }
      public string JavaOuterClassname {
        get { return javaOuterClassname_; }
      }
      
      // optional bool java_multiple_files = 10 [default = false];
      private bool hasJavaMultipleFiles;
      private boolean javaMultipleFiles_ = false;
      public boolean HasJavaMultipleFiles {
        get { return hasJavaMultipleFiles; }
      }
      public boolean JavaMultipleFiles {
        get { return javaMultipleFiles_; }
      }
      
      // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
      private boolean hasOptimizeFor;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode optimizeFor_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode.CODE_SIZE;
      public boolean HasOptimizeFor() { return hasOptimizeFor; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode GetOptimizeFor() { return optimizeFor_; }
      
      // optional string csharp_namespace = 1000;
      private bool hasCsharpNamespace;
      private string csharpNamespace_ = "";
      public boolean HasCsharpNamespace {
        get { return hasCsharpNamespace; }
      }
      public string CsharpNamespace {
        get { return csharpNamespace_; }
      }
      
      // optional string csharp_file_classname = 1001;
      private bool hasCsharpFileClassname;
      private string csharpFileClassname_ = "";
      public boolean HasCsharpFileClassname {
        get { return hasCsharpFileClassname; }
      }
      public string CsharpFileClassname {
        get { return csharpFileClassname_; }
      }
      
      // optional bool csharp_multiple_files = 1002 [default = false];
      private bool hasCsharpMultipleFiles;
      private boolean csharpMultipleFiles_ = false;
      public boolean HasCsharpMultipleFiles {
        get { return hasCsharpMultipleFiles; }
      }
      public boolean CsharpMultipleFiles {
        get { return csharpMultipleFiles_; }
      }
      
      // optional bool csharp_nest_classes = 1003 [default = false];
      private bool hasCsharpNestClasses;
      private boolean csharpNestClasses_ = false;
      public boolean HasCsharpNestClasses {
        get { return hasCsharpNestClasses; }
      }
      public boolean CsharpNestClasses {
        get { return csharpNestClasses_; }
      }
      
      // optional bool csharp_public_classes = 1004 [default = true];
      private bool hasCsharpPublicClasses;
      private boolean csharpPublicClasses_ = true;
      public boolean HasCsharpPublicClasses {
        get { return hasCsharpPublicClasses; }
      }
      public boolean CsharpPublicClasses {
        get { return csharpPublicClasses_; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasJavaPackage()) {
          output.writeString(1, getJavaPackage());
        }
        if (hasJavaOuterClassname()) {
          output.writeString(8, getJavaOuterClassname());
        }
        if (hasOptimizeFor()) {
          output.writeEnum(9, getOptimizeFor().getNumber());
        }
        if (hasJavaMultipleFiles()) {
          output.writeBool(10, getJavaMultipleFiles());
        }
        if (hasCsharpNamespace()) {
          output.writeString(1000, getCsharpNamespace());
        }
        if (hasCsharpFileClassname()) {
          output.writeString(1001, getCsharpFileClassname());
        }
        if (hasCsharpMultipleFiles()) {
          output.writeBool(1002, getCsharpMultipleFiles());
        }
        if (hasCsharpNestClasses()) {
          output.writeBool(1003, getCsharpNestClasses());
        }
        if (hasCsharpPublicClasses()) {
          output.writeBool(1004, getCsharpPublicClasses());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasJavaPackage()) {
            size += pb::CodedOutputStream
              .computeStringSize(1, getJavaPackage());
          }
          if (hasJavaOuterClassname()) {
            size += pb::CodedOutputStream
              .computeStringSize(8, getJavaOuterClassname());
          }
          if (hasOptimizeFor()) {
            size += pb::CodedOutputStream
              .computeEnumSize(9, getOptimizeFor().getNumber());
          }
          if (hasJavaMultipleFiles()) {
            size += pb::CodedOutputStream
              .computeBoolSize(10, getJavaMultipleFiles());
          }
          if (hasCsharpNamespace()) {
            size += pb::CodedOutputStream
              .computeStringSize(1000, getCsharpNamespace());
          }
          if (hasCsharpFileClassname()) {
            size += pb::CodedOutputStream
              .computeStringSize(1001, getCsharpFileClassname());
          }
          if (hasCsharpMultipleFiles()) {
            size += pb::CodedOutputStream
              .computeBoolSize(1002, getCsharpMultipleFiles());
          }
          if (hasCsharpNestClasses()) {
            size += pb::CodedOutputStream
              .computeBoolSize(1003, getCsharpNestClasses());
          }
          if (hasCsharpPublicClasses()) {
            size += pb::CodedOutputStream
              .computeBoolSize(1004, getCsharpPublicClasses());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.getDefaultInstance()) return this;
          if (other.hasJavaPackage()) {
            setJavaPackage(other.getJavaPackage());
          }
          if (other.hasJavaOuterClassname()) {
            setJavaOuterClassname(other.getJavaOuterClassname());
          }
          if (other.hasJavaMultipleFiles()) {
            setJavaMultipleFiles(other.getJavaMultipleFiles());
          }
          if (other.hasOptimizeFor()) {
            setOptimizeFor(other.getOptimizeFor());
          }
          if (other.hasCsharpNamespace()) {
            setCsharpNamespace(other.getCsharpNamespace());
          }
          if (other.hasCsharpFileClassname()) {
            setCsharpFileClassname(other.getCsharpFileClassname());
          }
          if (other.hasCsharpMultipleFiles()) {
            setCsharpMultipleFiles(other.getCsharpMultipleFiles());
          }
          if (other.hasCsharpNestClasses()) {
            setCsharpNestClasses(other.getCsharpNestClasses());
          }
          if (other.hasCsharpPublicClasses()) {
            setCsharpPublicClasses(other.getCsharpPublicClasses());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 10: {
                setJavaPackage(input.readString());
                break;
              }
              case 66: {
                setJavaOuterClassname(input.readString());
                break;
              }
              case 72: {
                int rawValue = input.readEnum();
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode value = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode.valueOf(rawValue);
                if (value == null) {
                  unknownFields.mergeVarintField(9, rawValue);
                } else {
                  setOptimizeFor(value);
                }
                break;
              }
              case 80: {
                setJavaMultipleFiles(input.readBool());
                break;
              }
              case 8002: {
                setCsharpNamespace(input.readString());
                break;
              }
              case 8010: {
                setCsharpFileClassname(input.readString());
                break;
              }
              case 8016: {
                setCsharpMultipleFiles(input.readBool());
                break;
              }
              case 8024: {
                setCsharpNestClasses(input.readBool());
                break;
              }
              case 8032: {
                setCsharpPublicClasses(input.readBool());
                break;
              }
            }
          }
        }
        
        
        // optional string java_package = 1;
        public boolean HasJavaPackage {
          get { return result.HasJavaPackage; }
        }
        public string JavaPackage {
          get { return result.JavaPackage; }
          set {
            result.hasJavaPackage = true;
            result.javaPackage_ = value;
          }
        }
        public Builder ClearJavaPackage() {
          result.hasJavaPackage = false;
          result.javaPackage_ = "";
          return this;
        }
        
        // optional string java_outer_classname = 8;
        public boolean HasJavaOuterClassname {
          get { return result.HasJavaOuterClassname; }
        }
        public string JavaOuterClassname {
          get { return result.JavaOuterClassname; }
          set {
            result.hasJavaOuterClassname = true;
            result.javaOuterClassname_ = value;
          }
        }
        public Builder ClearJavaOuterClassname() {
          result.hasJavaOuterClassname = false;
          result.javaOuterClassname_ = "";
          return this;
        }
        
        // optional bool java_multiple_files = 10 [default = false];
        public boolean HasJavaMultipleFiles {
          get { return result.HasJavaMultipleFiles; }
        }
        public boolean JavaMultipleFiles {
          get { return result.JavaMultipleFiles; }
          set {
            result.hasJavaMultipleFiles = true;
            result.javaMultipleFiles_ = value;
          }
        }
        public Builder ClearJavaMultipleFiles() {
          result.hasJavaMultipleFiles = false;
          result.javaMultipleFiles_ = false;
          return this;
        }
        
        // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
        public boolean HasOptimizeFor() {
          return result.HasOptimizeFor();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode GetOptimizeFor() {
          return result.GetOptimizeFor();
        }
        public Builder SetOptimizeFor(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode value) {
          result.hasOptimizeFor = true;
          result.optimizeFor_ = value;
          return this;
        }
        public Builder ClearOptimizeFor() {
          result.hasOptimizeFor = false;
          result.optimizeFor_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.OptimizeMode.CODE_SIZE;
          return this;
        }
        
        // optional string csharp_namespace = 1000;
        public boolean HasCsharpNamespace {
          get { return result.HasCsharpNamespace; }
        }
        public string CsharpNamespace {
          get { return result.CsharpNamespace; }
          set {
            result.hasCsharpNamespace = true;
            result.csharpNamespace_ = value;
          }
        }
        public Builder ClearCsharpNamespace() {
          result.hasCsharpNamespace = false;
          result.csharpNamespace_ = "";
          return this;
        }
        
        // optional string csharp_file_classname = 1001;
        public boolean HasCsharpFileClassname {
          get { return result.HasCsharpFileClassname; }
        }
        public string CsharpFileClassname {
          get { return result.CsharpFileClassname; }
          set {
            result.hasCsharpFileClassname = true;
            result.csharpFileClassname_ = value;
          }
        }
        public Builder ClearCsharpFileClassname() {
          result.hasCsharpFileClassname = false;
          result.csharpFileClassname_ = "";
          return this;
        }
        
        // optional bool csharp_multiple_files = 1002 [default = false];
        public boolean HasCsharpMultipleFiles {
          get { return result.HasCsharpMultipleFiles; }
        }
        public boolean CsharpMultipleFiles {
          get { return result.CsharpMultipleFiles; }
          set {
            result.hasCsharpMultipleFiles = true;
            result.csharpMultipleFiles_ = value;
          }
        }
        public Builder ClearCsharpMultipleFiles() {
          result.hasCsharpMultipleFiles = false;
          result.csharpMultipleFiles_ = false;
          return this;
        }
        
        // optional bool csharp_nest_classes = 1003 [default = false];
        public boolean HasCsharpNestClasses {
          get { return result.HasCsharpNestClasses; }
        }
        public boolean CsharpNestClasses {
          get { return result.CsharpNestClasses; }
          set {
            result.hasCsharpNestClasses = true;
            result.csharpNestClasses_ = value;
          }
        }
        public Builder ClearCsharpNestClasses() {
          result.hasCsharpNestClasses = false;
          result.csharpNestClasses_ = false;
          return this;
        }
        
        // optional bool csharp_public_classes = 1004 [default = true];
        public boolean HasCsharpPublicClasses {
          get { return result.HasCsharpPublicClasses; }
        }
        public boolean CsharpPublicClasses {
          get { return result.CsharpPublicClasses; }
          set {
            result.hasCsharpPublicClasses = true;
            result.csharpPublicClasses_ = value;
          }
        }
        public Builder ClearCsharpPublicClasses() {
          result.hasCsharpPublicClasses = false;
          result.csharpPublicClasses_ = true;
          return this;
        }
      }
    }
    
    public sealed class MessageOptions : pb::GeneratedMessage {
      // Use MessageOptions.newBuilder() to construct.
      private MessageOptions() {}
      
      private static readonly MessageOptions defaultInstance = new MessageOptions();
      public static MessageOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public MessageOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MessageOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MessageOptions_fieldAccessorTable; }
      }
      
      // optional bool message_set_wire_format = 1 [default = false];
      private bool hasMessageSetWireFormat;
      private boolean messageSetWireFormat_ = false;
      public boolean HasMessageSetWireFormat {
        get { return hasMessageSetWireFormat; }
      }
      public boolean MessageSetWireFormat {
        get { return messageSetWireFormat_; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasMessageSetWireFormat()) {
          output.writeBool(1, getMessageSetWireFormat());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasMessageSetWireFormat()) {
            size += pb::CodedOutputStream
              .computeBoolSize(1, getMessageSetWireFormat());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.getDefaultInstance()) return this;
          if (other.hasMessageSetWireFormat()) {
            setMessageSetWireFormat(other.getMessageSetWireFormat());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 8: {
                setMessageSetWireFormat(input.readBool());
                break;
              }
            }
          }
        }
        
        
        // optional bool message_set_wire_format = 1 [default = false];
        public boolean HasMessageSetWireFormat {
          get { return result.HasMessageSetWireFormat; }
        }
        public boolean MessageSetWireFormat {
          get { return result.MessageSetWireFormat; }
          set {
            result.hasMessageSetWireFormat = true;
            result.messageSetWireFormat_ = value;
          }
        }
        public Builder ClearMessageSetWireFormat() {
          result.hasMessageSetWireFormat = false;
          result.messageSetWireFormat_ = false;
          return this;
        }
      }
    }
    
    public sealed class FieldOptions : pb::GeneratedMessage {
      // Use FieldOptions.newBuilder() to construct.
      private FieldOptions() {}
      
      private static readonly FieldOptions defaultInstance = new FieldOptions();
      public static FieldOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public FieldOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FieldOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_FieldOptions_fieldAccessorTable; }
      }
      
      public enum CType {
        [pb::DescriptorIndex(0)]
        CORD = 1,
        [pb::DescriptorIndex(1)]
        STRING_PIECE = 2,
      }
      
      // optional .google.protobuf.FieldOptions.CType ctype = 1;
      private boolean hasCtype;
      private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType ctype_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType.CORD;
      public boolean HasCtype() { return hasCtype; }
      public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType GetCtype() { return ctype_; }
      
      // optional string experimental_map_key = 9;
      private bool hasExperimentalMapKey;
      private string experimentalMapKey_ = "";
      public boolean HasExperimentalMapKey {
        get { return hasExperimentalMapKey; }
      }
      public string ExperimentalMapKey {
        get { return experimentalMapKey_; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        if (hasCtype()) {
          output.writeEnum(1, getCtype().getNumber());
        }
        if (hasExperimentalMapKey()) {
          output.writeString(9, getExperimentalMapKey());
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          if (hasCtype()) {
            size += pb::CodedOutputStream
              .computeEnumSize(1, getCtype().getNumber());
          }
          if (hasExperimentalMapKey()) {
            size += pb::CodedOutputStream
              .computeStringSize(9, getExperimentalMapKey());
          }
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.getDefaultInstance()) return this;
          if (other.hasCtype()) {
            setCtype(other.getCtype());
          }
          if (other.hasExperimentalMapKey()) {
            setExperimentalMapKey(other.getExperimentalMapKey());
          }
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
              case 8: {
                int rawValue = input.readEnum();
                Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType value = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType.valueOf(rawValue);
                if (value == null) {
                  unknownFields.mergeVarintField(1, rawValue);
                } else {
                  setCtype(value);
                }
                break;
              }
              case 74: {
                setExperimentalMapKey(input.readString());
                break;
              }
            }
          }
        }
        
        
        // optional .google.protobuf.FieldOptions.CType ctype = 1;
        public boolean HasCtype() {
          return result.HasCtype();
        }
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType GetCtype() {
          return result.GetCtype();
        }
        public Builder SetCtype(Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType value) {
          result.hasCtype = true;
          result.ctype_ = value;
          return this;
        }
        public Builder ClearCtype() {
          result.hasCtype = false;
          result.ctype_ = Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.CType.CORD;
          return this;
        }
        
        // optional string experimental_map_key = 9;
        public boolean HasExperimentalMapKey {
          get { return result.HasExperimentalMapKey; }
        }
        public string ExperimentalMapKey {
          get { return result.ExperimentalMapKey; }
          set {
            result.hasExperimentalMapKey = true;
            result.experimentalMapKey_ = value;
          }
        }
        public Builder ClearExperimentalMapKey() {
          result.hasExperimentalMapKey = false;
          result.experimentalMapKey_ = "";
          return this;
        }
      }
    }
    
    public sealed class EnumOptions : pb::GeneratedMessage {
      // Use EnumOptions.newBuilder() to construct.
      private EnumOptions() {}
      
      private static readonly EnumOptions defaultInstance = new EnumOptions();
      public static EnumOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public EnumOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumOptions_fieldAccessorTable; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.getDefaultInstance()) return this;
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
            }
          }
        }
        
      }
    }
    
    public sealed class EnumValueOptions : pb::GeneratedMessage {
      // Use EnumValueOptions.newBuilder() to construct.
      private EnumValueOptions() {}
      
      private static readonly EnumValueOptions defaultInstance = new EnumValueOptions();
      public static EnumValueOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public EnumValueOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumValueOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_EnumValueOptions_fieldAccessorTable; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.getDefaultInstance()) return this;
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
            }
          }
        }
        
      }
    }
    
    public sealed class ServiceOptions : pb::GeneratedMessage {
      // Use ServiceOptions.newBuilder() to construct.
      private ServiceOptions() {}
      
      private static readonly ServiceOptions defaultInstance = new ServiceOptions();
      public static ServiceOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public ServiceOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_ServiceOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_ServiceOptions_fieldAccessorTable; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.getDefaultInstance()) return this;
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
            }
          }
        }
        
      }
    }
    
    public sealed class MethodOptions : pb::GeneratedMessage {
      // Use MethodOptions.newBuilder() to construct.
      private MethodOptions() {}
      
      private static readonly MethodOptions defaultInstance = new MethodOptions();
      public static MethodOptions DefaultInstance {
        get { return defaultInstance; }
      }
      
      public MethodOptions DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      public static pb::Descriptors.Descriptor Descriptor {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MethodOptions_descriptor; }
      }
      
      protected pb::GeneratedMessage.FieldAccessorTable InternalGetFieldAccessorTable {
        get { return Google.ProtocolBuffers.DescriptorProtos.Descriptor.internal_static_google_protobuf_MethodOptions_fieldAccessorTable; }
      }
      
      public final boolean isInitialized() {
        return true;
      }
      
      public void writeTo(pb::CodedOutputStream output) {
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          size += UnknownFieldsSerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(pb::ByteString data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(pb::ByteString data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(byte[] data) {
        return newBuilder().mergeFrom(data).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(byte[] data,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(data, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(global::System.IO.Stream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(
          global::System.IO.Stream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(pb::CodedInputStream input) {
        return newBuilder().mergeFrom(input).buildParsed();
      }
      public static Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions parseFrom(pb::CodedInputStream input,
          pb::ExtensionRegistry extensionRegistry) {
        return newBuilder().mergeFrom(input, extensionRegistry)
                 .buildParsed();
      }
      
      public static Builder newBuilder() { return new Builder(); }
      public Builder newBuilderForType() { return new Builder(); }
      public static Builder newBuilder(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions prototype) {
        return new Builder().mergeFrom(prototype);
      }
      
      public sealed class Builder : pb::GeneratedMessage.Builder<Builder> {
        // Construct using Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.newBuilder()
        private Builder() {}
        
        Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions();
        
        protected Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions internalGetResult() {
          return result;
        }
        
        public Builder clear() {
          result = new Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions();
          return this;
        }
        
        public Builder clone() {
          return new Builder().mergeFrom(result);
        }
        
        public pb::Descriptors.Descriptor
            getDescriptorForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDescriptor();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions getDefaultInstanceForType() {
          return Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDefaultInstance();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions build() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result);
          }
          return buildPartial();
        }
        
        private Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions buildParsed() {
          if (!isInitialized()) {
            throw new pb::UninitializedMessageException(
              result).asInvalidProtocolBufferException();
          }
          return buildPartial();
        }
        
        public Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions buildPartial() {
          Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions returnMe = result;
          result = null;
          return returnMe;
        }
        
        public Builder mergeFrom(pb::Message other) {
          if (other instanceof Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions) {
            return mergeFrom((Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions)other);
          } else {
            super.mergeFrom(other);
            return this;
          }
        }
        
        public Builder mergeFrom(Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions other) {
          if (other == Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.getDefaultInstance()) return this;
          this.mergeUnknownFields(other.getUnknownFields());
          return this;
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input) {
          return mergeFrom(input,
            pb::ExtensionRegistry.getEmptyRegistry());
        }
        
        public Builder mergeFrom(
            pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields =
            pb::UnknownFieldSet.newBuilder(
              this.getUnknownFields());
          while (true) {
            int tag = input.readTag();
            switch (tag) {
              case 0:
                this.setUnknownFields(unknownFields.build());
                return this;
              default: {
                if (!parseUnknownField(input, unknownFields,
                                       extensionRegistry, tag)) {
                  this.setUnknownFields(unknownFields.build());
                  return this;
                }
                break;
              }
            }
          }
        }
        
      }
    }
    
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_FileDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(0);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_FileDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_FileDescriptorProto_descriptor,
            new string[] { "Name", "Package", "Dependency", "MessageType", "EnumType", "Service", "Extension", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_DescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(1);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_DescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_DescriptorProto_descriptor,
            new string[] { "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_DescriptorProto_ExtensionRange_descriptor =
        internal_static_google_protobuf_DescriptorProto_descriptor.getNestedTypes().get(0);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_DescriptorProto_ExtensionRange_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_DescriptorProto_ExtensionRange_descriptor,
            new string[] { "Start", "End", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.DescriptorProto.ExtensionRange.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_FieldDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(2);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_FieldDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_FieldDescriptorProto_descriptor,
            new string[] { "Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_EnumDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(3);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_EnumDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_EnumDescriptorProto_descriptor,
            new string[] { "Name", "Value", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_EnumValueDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(4);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_EnumValueDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_EnumValueDescriptorProto_descriptor,
            new string[] { "Name", "Number", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_ServiceDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(5);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_ServiceDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_ServiceDescriptorProto_descriptor,
            new string[] { "Name", "Method", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_MethodDescriptorProto_descriptor =
        getDescriptor().getMessageTypes().get(6);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_MethodDescriptorProto_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_MethodDescriptorProto_descriptor,
            new string[] { "Name", "InputType", "OutputType", "Options", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodDescriptorProto.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_FileOptions_descriptor =
        getDescriptor().getMessageTypes().get(7);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_FileOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_FileOptions_descriptor,
            new string[] { "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "OptimizeFor", "CsharpNamespace", "CsharpFileClassname", "CsharpMultipleFiles", "CsharpNestClasses", "CsharpPublicClasses", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FileOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_MessageOptions_descriptor =
        getDescriptor().getMessageTypes().get(8);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_MessageOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_MessageOptions_descriptor,
            new string[] { "MessageSetWireFormat", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MessageOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_FieldOptions_descriptor =
        getDescriptor().getMessageTypes().get(9);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_FieldOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_FieldOptions_descriptor,
            new string[] { "Ctype", "ExperimentalMapKey", },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.FieldOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_EnumOptions_descriptor =
        getDescriptor().getMessageTypes().get(10);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_EnumOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_EnumOptions_descriptor,
            new string[] { },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_EnumValueOptions_descriptor =
        getDescriptor().getMessageTypes().get(11);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_EnumValueOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_EnumValueOptions_descriptor,
            new string[] { },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.EnumValueOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_ServiceOptions_descriptor =
        getDescriptor().getMessageTypes().get(12);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_ServiceOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_ServiceOptions_descriptor,
            new string[] { },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.ServiceOptions.Builder));
    private static readonly pb::Descriptors.Descriptor 
      internal_static_google_protobuf_MethodOptions_descriptor =
        getDescriptor().getMessageTypes().get(13);
    private static
      pb::GeneratedMessage.FieldAccessorTable
        internal_static_google_protobuf_MethodOptions_fieldAccessorTable = new
          pb::GeneratedMessage.FieldAccessorTable(
            internal_static_google_protobuf_MethodOptions_descriptor,
            new string[] { },
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions),
            typeof (Google.ProtocolBuffers.DescriptorProtos.Descriptor.MethodOptions.Builder));
  }
}