protobuf/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs

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

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
using self = global::Google.ProtocolBuffers.DescriptorProtos;

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