Final commit before changing layout

39 files changed, 4007 insertions, 1341 deletions

diff --git a/csharp/ProtoGen.Test/DependencyResolutionTest.cs b/csharp/ProtoGen.Test/DependencyResolutionTest.cs
index 1906c44d..ef911263 100644
--- a/csharp/ProtoGen.Test/DependencyResolutionTest.cs
+++ b/csharp/ProtoGen.Test/DependencyResolutionTest.cs
@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Google.ProtocolBuffers.Descriptors;
 using NUnit.Framework;
+using Google.ProtocolBuffers.DescriptorProtos;
+using Google.ProtocolBuffers.ProtoGen;
 
-namespace ProtoGen {
+namespace Google.ProtocolBuffers.ProtoGen {
   /// <summary>
   /// Tests for the dependency resolution in Generator.
   /// </summary>
@@ -12,6 +15,81 @@ namespace ProtoGen {
 
     [Test]
     public void TwoDistinctFiles() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name="First" }.Build();
+      FileDescriptorProto second = new FileDescriptorProto.Builder { Name="Second" }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
+
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      Assert.AreEqual(2, converted.Count);
+      Assert.AreEqual("First", converted[0].Name);
+      Assert.AreEqual(0, converted[0].Dependencies.Count);
+      Assert.AreEqual("Second", converted[1].Name);
+      Assert.AreEqual(0, converted[1].Dependencies.Count);
+    }
+
+    [Test]
+    public void FirstDependsOnSecond() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build();
+      FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      Assert.AreEqual(2, converted.Count);
+      Assert.AreEqual("First", converted[0].Name);
+      Assert.AreEqual(1, converted[0].Dependencies.Count);
+      Assert.AreEqual(converted[1], converted[0].Dependencies[0]);
+      Assert.AreEqual("Second", converted[1].Name);
+      Assert.AreEqual(0, converted[1].Dependencies.Count);
+    }
+
+    [Test]
+    public void SecondDependsOnFirst() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build();
+      FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
+      IList<FileDescriptor> converted = Generator.ConvertDescriptors(set);
+      Assert.AreEqual(2, converted.Count);
+      Assert.AreEqual("First", converted[0].Name);
+      Assert.AreEqual(0, converted[0].Dependencies.Count);
+      Assert.AreEqual("Second", converted[1].Name);
+      Assert.AreEqual(1, converted[1].Dependencies.Count);
+      Assert.AreEqual(converted[0], converted[1].Dependencies[0]);
+    }
+
+    [Test]
+    public void CircularDependency() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
+      FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } };
+      try {
+        Generator.ConvertDescriptors(set);
+        Assert.Fail("Expected exception");
+      } catch (DependencyResolutionException) {
+        // Expected
+      }
+    }
+
+    [Test]
+    public void MissingDependency() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
+      try {
+        Generator.ConvertDescriptors(set);
+        Assert.Fail("Expected exception");
+      } catch (DependencyResolutionException) {
+        // Expected
+      }
+    }
+
+    [Test]
+    public void SelfDependency() {
+      FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build();
+      FileDescriptorSet set = new FileDescriptorSet { FileList = { first } };
+      try {
+        Generator.ConvertDescriptors(set);
+        Assert.Fail("Expected exception");
+      } catch (DependencyResolutionException) {
+        // Expected
+      }
     }
   }
-}
+}
\ No newline at end of file
diff --git a/csharp/ProtoGen.Test/DescriptorUtilTest.cs b/csharp/ProtoGen.Test/DescriptorUtilTest.cs
new file mode 100644
index 00000000..5674892e
--- /dev/null
+++ b/csharp/ProtoGen.Test/DescriptorUtilTest.cs
@@ -0,0 +1,69 @@
+using Google.ProtocolBuffers.DescriptorProtos;
+using Google.ProtocolBuffers.Descriptors;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  [TestFixture]
+  public class DescriptorUtilTest {
+
+    [Test]
+    public void ExplicitNamespace() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder {
+        Name = "x", Package = "pack", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpNamespace, "Foo.Bar").Build()
+      }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("Foo.Bar", DescriptorUtil.GetNamespace(descriptor));
+    }
+
+    [Test]
+    public void NoNamespaceFallsBackToPackage() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x", Package = "pack" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("pack", DescriptorUtil.GetNamespace(descriptor));
+    }
+
+    [Test]
+    public void NoNamespaceOrPackageFallsBackToEmptyString() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("", DescriptorUtil.GetNamespace(descriptor));
+    }
+
+    [Test]
+    public void ExplicitlyNamedFileClass() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder {
+        Name = "x", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpUmbrellaClassname, "Foo").Build()
+      }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("Foo", DescriptorUtil.GetUmbrellaClassName(descriptor));
+    }
+
+    [Test]
+    public void ImplicitFileClassWithProtoSuffix() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.proto" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
+    }
+
+    [Test]
+    public void ImplicitFileClassWithProtoDevelSuffix() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.protodevel" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
+    }
+
+    [Test]
+    public void ImplicitFileClassWithNoSuffix() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
+    }
+
+    [Test]
+    public void ImplicitFileClassWithDirectoryStructure() {
+      FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x/y/foo_bar" }.Build();
+      FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
+      Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor));
+    }
+  }
+}
diff --git a/csharp/ProtoGen.Test/GeneratorTest.cs b/csharp/ProtoGen.Test/GeneratorTest.cs
index 137d9348..dbd18787 100644
--- a/csharp/ProtoGen.Test/GeneratorTest.cs
+++ b/csharp/ProtoGen.Test/GeneratorTest.cs
@@ -1,7 +1,10 @@
-using NUnit.Framework;
+using Google.ProtocolBuffers.DescriptorProtos;
+using NUnit.Framework;
+using Google.ProtocolBuffers.Descriptors;
 
-namespace ProtoGen {
+namespace Google.ProtocolBuffers.ProtoGen {
   [TestFixture]
   public class GeneratorTest {
+
   }
-}
+}
\ No newline at end of file
diff --git a/csharp/ProtoGen.Test/HelpersTest.cs b/csharp/ProtoGen.Test/HelpersTest.cs
new file mode 100644
index 00000000..af084973
--- /dev/null
+++ b/csharp/ProtoGen.Test/HelpersTest.cs
@@ -0,0 +1,33 @@
+using Google.ProtocolBuffers.ProtoGen;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  [TestFixture]
+  public class HelpersTest {
+
+    [Test]
+    public void UnderscoresToPascalCase() {
+      Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_bar"));
+      Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("foo_bar"));
+      Assert.AreEqual("Foo0Bar", Helpers.UnderscoresToPascalCase("Foo0bar"));
+      Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_+_Bar"));
+    }
+
+    [Test]
+    public void UnderscoresToCamelCase() {
+      Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_bar"));
+      Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("foo_bar"));
+      Assert.AreEqual("foo0Bar", Helpers.UnderscoresToCamelCase("Foo0bar"));
+      Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_+_Bar"));
+    }
+
+    [Test]
+    public void StripSuffix() {
+      string text = "FooBar";
+      Assert.IsFalse(Helpers.StripSuffix(ref text, "Foo"));
+      Assert.AreEqual("FooBar", text);
+      Assert.IsTrue(Helpers.StripSuffix(ref text, "Bar"));
+      Assert.AreEqual("Foo", text);
+    }
+  }
+}
\ No newline at end of file
diff --git a/csharp/ProtoGen.Test/ProtoGen.Test.csproj b/csharp/ProtoGen.Test/ProtoGen.Test.csproj
index c1c05243..83e6f961 100644
--- a/csharp/ProtoGen.Test/ProtoGen.Test.csproj
+++ b/csharp/ProtoGen.Test/ProtoGen.Test.csproj
@@ -8,7 +8,7 @@
     <ProjectGuid>{C268DA4C-4004-47DA-AF23-44C983281A68}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>ProtoGen</RootNamespace>
+    <RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace>
     <AssemblyName>Google.ProtocolBuffers.ProtoGen.Test</AssemblyName>
     <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
@@ -42,10 +42,14 @@
       <HintPath>..\lib\Rhino.Mocks.dll</HintPath>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="DependencyResolutionTest.cs" />
+    <Compile Include="DescriptorUtilTest.cs" />
     <Compile Include="GeneratorTest.cs" />
+    <Compile Include="HelpersTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/csharp/ProtoGen/DescriptorUtil.cs b/csharp/ProtoGen/DescriptorUtil.cs
new file mode 100644
index 00000000..e70ad468
--- /dev/null
+++ b/csharp/ProtoGen/DescriptorUtil.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+using Google.ProtocolBuffers.DescriptorProtos;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  /// <summary>
+  /// Utility class for determining namespaces etc.
+  /// </summary>
+  internal static class DescriptorUtil {
+
+    internal static bool NestClasses(IDescriptor descriptor) {
+      // Defaults to false
+      return descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses);
+    }
+
+    internal static string GetNamespace(FileDescriptor descriptor) {
+      if (descriptor.Name == "google/protobuf/descriptor.proto") {
+        return typeof(DescriptorProtoFile).Namespace;
+      }
+      return descriptor.Options.HasExtension(CSharpOptions.CSharpNamespace) ?
+          descriptor.Options.GetExtension(CSharpOptions.CSharpNamespace) : descriptor.Package;
+    }
+
+    // Groups are hacky:  The name of the field is just the lower-cased name
+    // of the group type.  In C#, though, we would like to retain the original
+    // capitalization of the type name.
+    internal static string GetFieldName(FieldDescriptor descriptor) {
+      if (descriptor.FieldType == FieldType.Group) {
+        return descriptor.MessageType.Name;
+      } else {
+        return descriptor.Name;
+      }
+    }
+
+    internal static string GetClassName(IDescriptor descriptor) {
+      return ToCSharpName(descriptor.FullName, descriptor.File);
+    }
+
+    internal static string GetFullUmbrellaClassName(FileDescriptor descriptor) {
+      string result = GetNamespace(descriptor);
+      if (result != "") result += '.';
+      result += GetUmbrellaClassName(descriptor);
+      return "global::" + result;
+    }
+
+    internal static string GetUmbrellaClassName(FileDescriptor descriptor) {
+      if (descriptor.Name == "google/protobuf/descriptor.proto") {
+        return typeof(DescriptorProtoFile).Name;
+      }
+      FileOptions options = descriptor.Options;
+      if (options.HasExtension(CSharpOptions.CSharpUmbrellaClassname)) {
+        return descriptor.Options.GetExtension(CSharpOptions.CSharpUmbrellaClassname);
+      }
+      int lastSlash = descriptor.Name.LastIndexOf('/');
+      string baseName = descriptor.Name.Substring(lastSlash + 1);
+      return Helpers.UnderscoresToPascalCase(StripProto(baseName));
+    }
+
+    private static string StripProto(string text) {
+      if (!Helpers.StripSuffix(ref text, ".protodevel")) {
+        Helpers.StripSuffix(ref text, ".proto");
+      }
+      return text;
+    }
+
+    private static string ToCSharpName(string name, FileDescriptor file) {
+      string result;
+      if (!NestClasses(file)) {
+        result = GetNamespace(file);
+      } else {
+        result = GetUmbrellaClassName(file);
+      }
+      if (result != "") {
+        result += '.';
+      }
+      string classname;
+      if (file.Package == "") {
+        classname = name;
+      } else {
+        // Strip the proto package from full_name since we've replaced it with
+        // the C# namespace.
+        classname = name.Substring(file.Package.Length + 1);
+      }
+      result += classname.Replace(".", ".Types.");
+      return "global::" + result;
+    }
+
+    internal static string GetMappedTypeName(MappedType type) {
+      switch(type) {
+        case MappedType.Int32:      return "int";
+        case MappedType.Int64:      return "long";
+        case MappedType.UInt32:     return "uint";
+        case MappedType.UInt64:     return "ulong";
+        case MappedType.Single:     return "float";
+        case MappedType.Double:     return "double";
+        case MappedType.Boolean:    return "bool";
+        case MappedType.String:     return "string";
+        case MappedType.ByteString: return "pb::ByteString";
+        case MappedType.Enum:       return null;
+        case MappedType.Message:    return null;
+        default:
+          throw new ArgumentOutOfRangeException("Unknown mapped type " + type);
+      }
+    }
+  }
+}
diff --git a/csharp/ProtoGen/EnumFieldGenerator.cs b/csharp/ProtoGen/EnumFieldGenerator.cs
new file mode 100644
index 00000000..9f6a56f2
--- /dev/null
+++ b/csharp/ProtoGen/EnumFieldGenerator.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class EnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+    internal EnumFieldGenerator(FieldDescriptor descriptor)
+        : base(descriptor) {
+    }
+
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private bool has{0};", CapitalizedName);
+      writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine("  get {{ return has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
+      writer.WriteLine("  get {{ return {0}_; }}", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
+      writer.WriteLine("  get {{ return result.{0}; }}", PropertyName);
+      writer.WriteLine("  set {{ Set{0}(value); }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.has{0} = true;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.has{0} = false;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = {1};", Name, DefaultValue);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  {0} = other.{0};", PropertyName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      // Nothing to do here for enum types
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      // TODO(jonskeet): Make a more efficient way of doing this
+      writer.WriteLine("int rawValue = input.ReadEnum();");
+      writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
+      writer.WriteLine("  unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number);
+      writer.WriteLine("} else {");
+      writer.WriteLine("  {0} = ({1}) rawValue;", PropertyName, TypeName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  output.WriteEnum({0}, (int) {1});", Number, PropertyName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) {1});", Number, PropertyName);
+      writer.WriteLine("}");    
+    }
+  }
+}
diff --git a/csharp/ProtoGen/EnumGenerator.cs b/csharp/ProtoGen/EnumGenerator.cs
new file mode 100644
index 00000000..0de6b89c
--- /dev/null
+++ b/csharp/ProtoGen/EnumGenerator.cs
@@ -0,0 +1,19 @@
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class EnumGenerator : SourceGeneratorBase<EnumDescriptor>, ISourceGenerator {
+    internal EnumGenerator(EnumDescriptor descriptor) : base(descriptor) {
+    }
+
+    public void Generate(TextGenerator writer) {
+      writer.WriteLine("{0} enum {1} {{", ClassAccessLevel, Descriptor.Name);
+      writer.Indent();
+      foreach (EnumValueDescriptor value in Descriptor.Values) {
+        writer.WriteLine("{0} = {1},", value.Name, value.Number);
+      }
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+  }
+}
diff --git a/csharp/ProtoGen/ExtensionGenerator.cs b/csharp/ProtoGen/ExtensionGenerator.cs
new file mode 100644
index 00000000..9c235456
--- /dev/null
+++ b/csharp/ProtoGen/ExtensionGenerator.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class ExtensionGenerator : SourceGeneratorBase<FieldDescriptor>, ISourceGenerator {
+    internal ExtensionGenerator(FieldDescriptor descriptor) : base(descriptor) {
+    }
+
+    public void Generate(TextGenerator writer) {
+      string name = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor));
+
+      string type;
+      switch (Descriptor.MappedType) {
+        case MappedType.Message:
+          type = DescriptorUtil.GetClassName(Descriptor.MessageType);
+          break;
+        case MappedType.Enum:
+          type = DescriptorUtil.GetClassName(Descriptor.EnumType);
+          break;
+        default:
+          type = DescriptorUtil.GetMappedTypeName(Descriptor.MappedType);
+          break;
+      }
+
+      if (Descriptor.IsRepeated) {
+        writer.WriteLine("{0} static readonly", ClassAccessLevel);
+        writer.WriteLine("    pb::GeneratedExtensionBase<scg::IList<{0}>> {1} =", type, name);
+        writer.WriteLine("    pb::GeneratedRepeatExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index);
+      } else {
+        writer.WriteLine("{0} static readonly pb::GeneratedExtensionBase<{1}> {2} =", ClassAccessLevel, type, name);
+        writer.WriteLine("    pb::GeneratedSingleExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index);
+      }
+    }
+  }
+}
diff --git a/csharp/ProtoGen/FieldGeneratorBase.cs b/csharp/ProtoGen/FieldGeneratorBase.cs
new file mode 100644
index 00000000..9103e0c1
--- /dev/null
+++ b/csharp/ProtoGen/FieldGeneratorBase.cs
@@ -0,0 +1,130 @@
+using System;
+using Google.ProtocolBuffers.Descriptors;
+using System.Globalization;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal abstract class FieldGeneratorBase : SourceGeneratorBase<FieldDescriptor> {
+    protected FieldGeneratorBase(FieldDescriptor descriptor)
+        : base(descriptor) {
+    }
+
+    private static bool AllPrintableAscii(string text) {
+      foreach (char c in text) {
+        if (c < 0x20 || c > 0x7e) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    protected string DefaultValue {
+      get {
+        string suffix = "";
+        switch (Descriptor.FieldType) {
+          case FieldType.Float:  suffix = "F"; break;
+          case FieldType.Double: suffix = "D"; break;
+          case FieldType.Int64:  suffix = "L"; break;
+          case FieldType.UInt64: suffix = "UL"; break;
+        }
+        switch (Descriptor.FieldType) {
+          case FieldType.Float:
+          case FieldType.Double:
+          case FieldType.Int32:
+          case FieldType.Int64:
+          case FieldType.SInt32:
+          case FieldType.SInt64:
+          case FieldType.SFixed32:
+          case FieldType.SFixed64:
+          case FieldType.UInt32:
+          case FieldType.UInt64:
+          case FieldType.Fixed32:
+          case FieldType.Fixed64:
+            // The simple Object.ToString converts using the current culture.
+            // We want to always use the invariant culture so it's predictable.
+            IConvertible value = (IConvertible) Descriptor.DefaultValue;
+            return value.ToString(CultureInfo.InvariantCulture) + suffix;
+          case FieldType.Bool:
+            return (bool) Descriptor.DefaultValue ? "true" : "false";
+
+          case FieldType.Bytes:
+            if (!Descriptor.HasDefaultValue) {
+              return "pb::ByteString.Empty";
+            }
+            return string.Format("(pb::ByteString) {0}.Descriptor.Fields[{1}].DefaultValue", TypeName, Number);
+          case FieldType.String:
+            if (AllPrintableAscii(Descriptor.Proto.DefaultValue)) {
+              // All chars are ASCII and printable.  In this case we only
+              // need to escape quotes and backslashes.
+              return "\"" + Descriptor.Proto.DefaultValue
+                  .Replace("\\", "\\\\")
+                  .Replace("'", "\\'")
+                  .Replace("\"", "\\\"")
+                  + "\"";
+            }
+            return string.Format("(string) {0}.Descriptor.Fields[{1}].DefaultValue", TypeName, Number);
+          case FieldType.Enum:
+            return TypeName + "." + ((EnumValueDescriptor) Descriptor.DefaultValue).Name;
+          case FieldType.Message:
+          case FieldType.Group:
+            return TypeName + ".DefaultInstance";
+          default:
+            throw new InvalidOperationException("Invalid field descriptor type");
+        }
+      }
+    }
+
+    /// <summary>
+    /// Usually the same as CapitalizedName, except when the enclosing type has the same name,
+    /// in which case an underscore is appended.
+    /// </summary>
+    protected string PropertyName {
+      get {
+        string ret = CapitalizedName;
+        if (ret == Descriptor.ContainingType.Name) {
+          ret += "_";
+        }
+        return ret;
+      }
+    }
+
+    protected string CapitalizedName {
+      get { return Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor)); }
+    }
+
+    protected string Name {
+      get { return Helpers.UnderscoresToCamelCase(DescriptorUtil.GetFieldName(Descriptor)); }
+    }
+
+    protected int Number {
+      get { return Descriptor.FieldNumber; }
+    }
+
+    protected string TypeName {
+      get {
+        switch (Descriptor.FieldType) {
+          case FieldType.Enum:
+            return DescriptorUtil.GetClassName(Descriptor.EnumType);
+          case FieldType.Message:
+          case FieldType.Group:
+            return DescriptorUtil.GetClassName(Descriptor.MessageType);
+          default:
+            return DescriptorUtil.GetMappedTypeName(Descriptor.MappedType);
+        }
+      }
+    }
+
+    protected string MessageOrGroup {
+      get { return Descriptor.FieldType == FieldType.Group ? "Group" : "Message"; }
+    }
+
+    /// <summary>
+    /// Returns the type name as used in CodedInputStream method names: SFixed32, UInt32 etc.
+    /// </summary>
+    protected string CapitalizedTypeName {
+      get {
+        // Our enum names match perfectly. How serendipitous.
+        return Descriptor.FieldType.ToString();
+      }
+    }
+  }
+}
diff --git a/csharp/ProtoGen/Generator.cs b/csharp/ProtoGen/Generator.cs
index d1ff76b2..f656386b 100644
--- a/csharp/ProtoGen/Generator.cs
+++ b/csharp/ProtoGen/Generator.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
 using Google.ProtocolBuffers.DescriptorProtos;
 using System.IO;
 using Google.ProtocolBuffers.Descriptors;
+using Google.ProtocolBuffers.Collections;
 
 namespace Google.ProtocolBuffers.ProtoGen {
   /// <summary>
@@ -26,22 +28,111 @@ namespace Google.ProtocolBuffers.ProtoGen {
 
     public void Generate() {
       foreach (string inputFile in options.InputFiles) {
-        FileDescriptorSet descriptorProtos;
+        FileDescriptorSet descriptorProtos;       
+        ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance();
+        extensionRegistry.Add(CSharpOptions.CSharpUmbrellaClassname);
+        extensionRegistry.Add(CSharpOptions.CSharpMultipleFiles);
+        extensionRegistry.Add(CSharpOptions.CSharpNamespace);
+        extensionRegistry.Add(CSharpOptions.CSharpNestClasses);
+        extensionRegistry.Add(CSharpOptions.CSharpPublicClasses);
         using (Stream inputStream = File.OpenRead(inputFile)) {
-          descriptorProtos = FileDescriptorSet.ParseFrom(inputStream);
+          descriptorProtos = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry);
         }
-        List<FileDescriptor> descriptors = ConvertDescriptors(descriptorProtos);
+        IList<FileDescriptor> descriptors = ConvertDescriptors(descriptorProtos);
+
+        foreach (FileDescriptor descriptor in descriptors) {
+          Generate(descriptor);
+        }
+      }
+    }
+
+    /// <summary>
+    /// Generates code for a particular file. All dependencies must
+    /// already have been resolved.
+    /// </summary>
+    private void Generate(FileDescriptor descriptor) {
+      string umbrellaClass = DescriptorUtil.GetUmbrellaClassName(descriptor);
+      string ns = DescriptorUtil.GetNamespace(descriptor);
+      using (TextWriter textWriter = File.CreateText(Path.Combine(options.OutputDirectory, umbrellaClass + ".cs"))) {
+        TextGenerator writer = new TextGenerator(textWriter);
+        
+        UmbrellaClassGenerator ucg = new UmbrellaClassGenerator(descriptor);
+        ucg.Generate(writer);
+        /*
+        GenerateSiblings(umbrellaSource, descriptor, descriptor.MessageTypes);
+        GenerateSiblings(umbrellaSource, descriptor, descriptor.EnumTypes);
+        GenerateSiblings(umbrellaSource, descriptor, descriptor.Services);*/
       }
     }
 
+    private static void GenerateSiblings<T>(SourceFileGenerator parentSourceGenerator, FileDescriptor file, IEnumerable<T> siblings)
+        where T : IDescriptor {
+    }
+
     /// <summary>
     /// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors.
     /// The list returned is in the same order as the protos are listed in the descriptor set.
     /// Note: this method is internal rather than private to allow testing.
     /// </summary>
     /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception>
-    internal static List<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) {
-      return null;
+    internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) {
+      // Simple strategy: Keep going through the list of protos to convert, only doing ones where
+      // we've already converted all the dependencies, until we get to a stalemate
+      IList<FileDescriptorProto> fileList = descriptorProtos.FileList;
+      FileDescriptor[] converted = new FileDescriptor[fileList.Count];
+
+      Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>();
+
+      int totalConverted = 0;
+
+      bool madeProgress = true;
+      while (madeProgress && totalConverted < converted.Length) {
+        madeProgress = false;
+        for (int i = 0; i < converted.Length; i++) {
+          if (converted[i] != null) {
+            // Already done this one
+            continue;
+          }
+          FileDescriptorProto candidate = fileList[i];
+          FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count];
+          bool foundAllDependencies = true;
+          for (int j = 0; j < dependencies.Length; j++) {
+            if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) {
+              foundAllDependencies = false;
+              break;
+            }
+          }
+          if (!foundAllDependencies) {
+            continue;
+          }
+          madeProgress = true;
+          totalConverted++;
+          converted[i] = FileDescriptor.BuildFrom(candidate, dependencies);
+          convertedMap[candidate.Name] = converted[i];
+        }
+      }
+      if (!madeProgress) {
+        StringBuilder remaining = new StringBuilder();
+        for (int i = 0; i < converted.Length; i++) {
+          if (converted[i] == null) {
+            if (remaining.Length != 0) {
+              remaining.Append(", ");
+            }
+            FileDescriptorProto failure = fileList[i];
+            remaining.Append(failure.Name);
+            remaining.Append(":");
+            foreach (string dependency in failure.DependencyList) {
+              if (!convertedMap.ContainsKey(dependency)) {
+                remaining.Append(" ");
+                remaining.Append(dependency);
+              }
+            }
+            remaining.Append(";");
+          }
+        }
+        throw new DependencyResolutionException("Unable to resolve all dependencies: " + remaining);
+      }
+      return Lists.AsReadOnly(converted);
     }
   }
 }
diff --git a/csharp/ProtoGen/Helpers.cs b/csharp/ProtoGen/Helpers.cs
new file mode 100644
index 00000000..79a2912c
--- /dev/null
+++ b/csharp/ProtoGen/Helpers.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Text;
+using Google.ProtocolBuffers.DescriptorProtos;
+using Google.ProtocolBuffers.Descriptors;
+namespace Google.ProtocolBuffers.ProtoGen {
+
+  /// <summary>
+  /// Helpers to resolve class names etc.
+  /// </summary>
+  internal static class Helpers {
+    internal static string UnderscoresToPascalCase(string input) {
+      return UnderscoresToPascalOrCamelCase(input, true);
+    }
+
+    internal static string UnderscoresToCamelCase(string input) {
+      return UnderscoresToPascalOrCamelCase(input, false);
+    }
+
+    internal static void WriteNamespaces(TextGenerator writer) {
+      writer.WriteLine("using pb = global::Google.ProtocolBuffers;");
+      writer.WriteLine("using pbc = global::Google.ProtocolBuffers.Collections;");
+      writer.WriteLine("using pbd = global::Google.ProtocolBuffers.Descriptors;");
+      writer.WriteLine("using scg = global::System.Collections.Generic;");
+    }
+
+    /// <summary>
+    /// Converts a string to Pascal or Camel case. The first letter is capitalized or
+    /// lower-cased depending on <paramref name="pascal"/> is true. 
+    /// After the first letter, any punctuation is removed but triggers capitalization
+    /// of the next letter. Digits are preserved but trigger capitalization of the next
+    /// letter.
+    /// All capitalisation is done in the invariant culture. 
+    /// </summary>
+    private static string UnderscoresToPascalOrCamelCase(string input, bool pascal) {
+      StringBuilder result = new StringBuilder();
+      bool capitaliseNext = pascal;
+      for (int i=0; i < input.Length; i++) {
+        char c = input[i];
+        if ('a' <= c && c <= 'z') {
+          if (capitaliseNext) {
+            result.Append(char.ToUpperInvariant(c));
+          } else {
+            result.Append(c);
+          }
+          capitaliseNext = false;
+        } else if ('A' <= c && c <= 'Z') {
+          if (i == 0 && !pascal) {
+            // Force first letter to lower-case unless explicitly told to
+            // capitalize it.
+            result.Append(char.ToLowerInvariant(c));
+          } else {
+            // Capital letters after the first are left as-is.
+            result.Append(c);
+          }
+          capitaliseNext = false;
+        } else if ('0' <= c && c <= '9') {
+          result.Append(c);
+          capitaliseNext = true;
+        } else {
+          capitaliseNext = true;
+        }
+      }
+      return result.ToString();
+    }
+
+    /// <summary>
+    /// Attempts to strip a suffix from a string, returning whether
+    /// or not the suffix was actually present.
+    /// </summary>
+    internal static bool StripSuffix(ref string text, string suffix) {
+      if (text.EndsWith(suffix)) {
+        text = text.Substring(0, text.Length - suffix.Length);
+        return true;
+      }
+      return false;
+    }
+  }
+}
diff --git a/csharp/ProtoGen/IFieldSourceGenerator.cs b/csharp/ProtoGen/IFieldSourceGenerator.cs
new file mode 100644
index 00000000..a64043c8
--- /dev/null
+++ b/csharp/ProtoGen/IFieldSourceGenerator.cs
@@ -0,0 +1,11 @@
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal interface IFieldSourceGenerator {
+    void GenerateMembers(TextGenerator writer);
+    void GenerateBuilderMembers(TextGenerator writer);
+    void GenerateMergingCode(TextGenerator writer);
+    void GenerateBuildingCode(TextGenerator writer);
+    void GenerateParsingCode(TextGenerator writer);
+    void GenerateSerializationCode(TextGenerator writer);
+    void GenerateSerializedSizeCode(TextGenerator writer);
+  }
+}
diff --git a/csharp/ProtoGen/ISourceGenerator.cs b/csharp/ProtoGen/ISourceGenerator.cs
new file mode 100644
index 00000000..16e7c29a
--- /dev/null
+++ b/csharp/ProtoGen/ISourceGenerator.cs
@@ -0,0 +1,5 @@
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal interface ISourceGenerator {
+    void Generate(TextGenerator writer);
+  }
+}
diff --git a/csharp/ProtoGen/MessageFieldGenerator.cs b/csharp/ProtoGen/MessageFieldGenerator.cs
new file mode 100644
index 00000000..c73edfc0
--- /dev/null
+++ b/csharp/ProtoGen/MessageFieldGenerator.cs
@@ -0,0 +1,92 @@
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class MessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+
+    internal MessageFieldGenerator(FieldDescriptor descriptor)
+      : base(descriptor) {
+    }
+
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private bool has{0};", CapitalizedName);
+      writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine("  get {{ return has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return {0}_; }}", Name);
+      writer.WriteLine("}");
+    }
+    
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}; }}", CapitalizedName);
+      writer.WriteLine("  set {{ Set{0}(value); }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.has{0} = true;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.has{0} = true;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = builderForValue.Build();", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Merge{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  if (result.Has{0} &&", CapitalizedName);
+      writer.WriteLine("      result.{0}_ != {1}) {{", Name, DefaultValue);
+      writer.WriteLine("      result.{0}_ = {1}.CreateBuilder(result.{0}_).MergeFrom(value).BuildPartial();", Name, TypeName);
+      writer.WriteLine("  } else {");
+      writer.WriteLine("    result.{0}_ = value;", Name);
+      writer.WriteLine("  }");
+      writer.WriteLine("  result.has{0} = true;", CapitalizedName);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.has{0} = false;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = {1};", Name, DefaultValue);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  Merge{0}(other.{0});", CapitalizedName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      // Nothing to do for singular fields
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName);
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  subBuilder.MergeFrom({0});", CapitalizedName);
+      writer.WriteLine("}");
+      if (Descriptor.FieldType == FieldType.Group) {
+        writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number);
+      } else {
+        writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);");
+      }
+      writer.WriteLine("{0} = subBuilder.BuildPartial();", CapitalizedName);
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  output.Write{0}({1}, {2});", MessageOrGroup, Number, CapitalizedName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.Compute{0}Size({1}, {2});",
+          MessageOrGroup, Number, CapitalizedName);
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/MessageGenerator.cs b/csharp/ProtoGen/MessageGenerator.cs
new file mode 100644
index 00000000..ba48c85c
--- /dev/null
+++ b/csharp/ProtoGen/MessageGenerator.cs
@@ -0,0 +1,453 @@
+using System.Collections;
+using Google.ProtocolBuffers.Descriptors;
+using Google.ProtocolBuffers.DescriptorProtos;
+using System.Collections.Generic;
+
+using ExtensionRange = Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class MessageGenerator : SourceGeneratorBase<MessageDescriptor>, ISourceGenerator {
+    internal MessageGenerator(MessageDescriptor descriptor) : base(descriptor) {
+    }
+
+    private string ClassName {
+      get { return Descriptor.Name; }
+    }
+
+    private string FullClassName {
+      get { return DescriptorUtil.GetClassName(Descriptor); }
+    }
+
+    /// <summary>
+    /// Get an identifier that uniquely identifies this type within the file.
+    /// This is used to declare static variables related to this type at the
+    /// outermost file scope.
+    /// </summary>
+    static string GetUniqueFileScopeIdentifier(IDescriptor descriptor) {
+      return "static_" + descriptor.FullName.Replace(".", "_");
+    }
+
+    internal void GenerateStaticVariables(TextGenerator writer) {
+      // Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is
+      // used in the construction of descriptors, we have a tricky bootstrapping
+      // problem.  To help control static initialization order, we make sure all
+      // descriptors and other static data that depends on them are members of
+      // the proto-descriptor class.  This way, they will be initialized in
+      // a deterministic order.
+
+      string identifier = GetUniqueFileScopeIdentifier(Descriptor);
+
+      // The descriptor for this type.
+      string access = Descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses) ? "private" : "internal";
+      writer.WriteLine("{0} static readonly pbd::MessageDescriptor internal__{1}__Descriptor", access, identifier);
+      if (Descriptor.ContainingType == null) {
+        writer.WriteLine("    = Descriptor.MessageTypes[{0}];", Descriptor.Index);
+      } else {
+        writer.WriteLine("    = internal__{0}__Descriptor.NestedTypes[{1}];", GetUniqueFileScopeIdentifier(Descriptor.ContainingType), Descriptor.Index);
+      }
+      writer.WriteLine("{0} static pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder> internal__{2}__FieldAccessorTable",
+          access, FullClassName, identifier);
+      writer.WriteLine("    = new pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder>(internal__{1}__Descriptor,",
+          FullClassName, identifier);
+      writer.Print("        new string[] { ");
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        writer.Write("\"{0}\", ", Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field)));
+      }
+      writer.WriteLine("});");
+
+      // Generate static members for all nested types.
+      foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes) {
+        new MessageGenerator(nestedMessage).GenerateStaticVariables(writer);
+      }
+    }
+
+    public void Generate(TextGenerator writer) {
+      writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message<{1}, {1}.Builder> {{",
+          ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated");
+      writer.Indent();
+      // Must call BuildPartial() to make sure all lists are made read-only
+      writer.WriteLine("private static readonly {0} defaultInstance = new Builder().BuildPartial();", ClassName);
+      writer.WriteLine("public static {0} DefaultInstance {{", ClassName);
+      writer.WriteLine("  get { return defaultInstance; }");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
+      writer.WriteLine("  get { return defaultInstance; }");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("protected override {0} ThisMessage {{", ClassName);
+      writer.WriteLine("  get { return this; }");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public static pbd::MessageDescriptor Descriptor {");
+      writer.WriteLine("  get {{ return {0}.internal__{1}__Descriptor; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File),
+          GetUniqueFileScopeIdentifier(Descriptor));
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{", ClassName);
+      writer.WriteLine("  get {{ return {0}.internal__{1}__FieldAccessorTable; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File),
+          GetUniqueFileScopeIdentifier(Descriptor));
+      writer.WriteLine("}");
+      writer.WriteLine();
+
+      // Extensions don't need to go in an extra nested type 
+      WriteChildren(writer, null, Descriptor.Extensions);
+
+      if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0) {
+        writer.WriteLine("#region Nested types");
+        writer.WriteLine("public static class Types {");
+        writer.Indent();
+        WriteChildren(writer, null, Descriptor.EnumTypes);
+        WriteChildren(writer, null, Descriptor.NestedTypes);
+        writer.Outdent();
+        writer.WriteLine("}");
+        writer.WriteLine("#endregion");
+        writer.WriteLine();
+      }
+
+      foreach(FieldDescriptor fieldDescriptor in Descriptor.Fields) {
+        // Rats: we lose the debug comment here :(
+        SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer);
+        writer.WriteLine();
+      }
+
+      if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
+        GenerateIsInitialized(writer);
+        GenerateMessageSerializationMethods(writer);
+      }
+
+      GenerateParseFromMethods(writer);
+      GenerateBuilder(writer);
+    }
+
+    private void GenerateMessageSerializationMethods(TextGenerator writer) {
+      List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
+      sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
+
+      List<ExtensionRange> sortedExtensions = new List<ExtensionRange>(Descriptor.Proto.ExtensionRangeList);
+      sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start)));
+
+      writer.WriteLine("public override void WriteTo(pb::CodedOutputStream output) {");
+      writer.Indent();
+      if (Descriptor.Proto.ExtensionRangeList.Count > 0) {
+        writer.WriteLine("pb::ExtendableMessage<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);",
+          ClassName);
+      }
+
+      // Merge the fields and the extension ranges, both sorted by field number.
+      for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count; ) {
+        if (i == Descriptor.Fields.Count) {
+          GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
+        } else if (j == sortedExtensions.Count) {
+          GenerateSerializeOneField(writer, sortedFields[i++]);
+        } else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start) {
+          GenerateSerializeOneField(writer, sortedFields[i++]);
+        } else {
+          GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]);
+        }
+      }
+
+      if (Descriptor.Proto.Options.MessageSetWireFormat) {
+        writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);");
+      } else {
+        writer.WriteLine("UnknownFields.WriteTo(output);");
+      }
+
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("private int memoizedSerializedSize = -1;");
+      writer.WriteLine("public override int SerializedSize {");
+      writer.Indent();
+      writer.WriteLine("get {");
+      writer.Indent();
+      writer.WriteLine("int size = memoizedSerializedSize;");
+      writer.WriteLine("if (size != -1) return size;");
+      writer.WriteLine();
+      writer.WriteLine("size = 0;");
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        SourceGenerators.CreateFieldGenerator(field).GenerateSerializedSizeCode(writer);
+      }
+      if (Descriptor.Proto.ExtensionRangeCount > 0) {
+        writer.WriteLine("size += ExtensionsSerializedSize;");
+      }
+
+      if (Descriptor.Options.MessageSetWireFormat) {
+        writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;");
+      } else {
+        writer.WriteLine("size += UnknownFields.SerializedSize;");
+      }
+      writer.WriteLine("memoizedSerializedSize = size;");
+      writer.WriteLine("return size;");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+
+    private static void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor) {
+      SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer);
+    }
+
+    private static void GenerateSerializeOneExtensionRange(TextGenerator writer, ExtensionRange extensionRange) {
+      writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End);
+    }
+
+    private void GenerateParseFromMethods(TextGenerator writer) {
+      // Note:  These are separate from GenerateMessageSerializationMethods()
+      //   because they need to be generated even for messages that are optimized
+      //   for code size.
+
+      writer.WriteLine("public static {0} ParseFrom(pb::ByteString data) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(byte[] data) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();");
+      writer.WriteLine("}");
+      writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName);
+      writer.WriteLine("  return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();");
+      writer.WriteLine("}");
+    }
+
+    /// <summary>
+    /// Returns whether or not the specified message type has any required fields.
+    /// If it doesn't, calls to check for initialization can be optimised.
+    /// TODO(jonskeet): Move this into MessageDescriptor?
+    /// </summary>
+    private static bool HasRequiredFields(MessageDescriptor descriptor, Dictionary<MessageDescriptor,object> alreadySeen) {
+      if (alreadySeen.ContainsKey(descriptor)) {
+        // The type is already in cache.  This means that either:
+        // a. The type has no required fields.
+        // b. We are in the midst of checking if the type has required fields,
+        //    somewhere up the stack.  In this case, we know that if the type
+        //    has any required fields, they'll be found when we return to it,
+        //    and the whole call to HasRequiredFields() will return true.
+        //    Therefore, we don't have to check if this type has required fields
+        //    here.
+        return false;
+      }
+      alreadySeen[descriptor] = descriptor; // Value is irrelevant
+
+      // If the type has extensions, an extension with message type could contain
+      // required fields, so we have to be conservative and assume such an
+      // extension exists.
+      if (descriptor.Extensions.Count > 0) {
+        return true;
+      }
+
+      foreach (FieldDescriptor field in descriptor.Fields) {
+        if (field.IsRequired) {
+          return true;
+        }
+        // Message or group
+        if (field.MappedType == MappedType.Message) {
+          if (HasRequiredFields(field.MessageType, alreadySeen)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    private void GenerateBuilder(TextGenerator writer) {
+      writer.WriteLine("public static Builder CreateBuilder() { return new Builder(); }");
+      writer.WriteLine("public override Builder CreateBuilderForType() { return new Builder(); }");
+      writer.WriteLine("public static Builder CreateBuilder({0} prototype) {{", ClassName);
+      writer.WriteLine("  return (Builder) new Builder().MergeFrom(prototype);");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("{0} sealed partial class Builder : pb::{2}Builder<{1}, Builder> {{",
+          ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated");
+      writer.Indent();
+      writer.WriteLine("protected override Builder ThisBuilder {");
+      writer.WriteLine("  get { return this; }");
+      writer.WriteLine("}");
+      GenerateCommonBuilderMethods(writer);
+      if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
+        GenerateBuilderParsingMethods(writer);
+      }
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        writer.WriteLine();
+        // No field comment :(
+        SourceGenerators.CreateFieldGenerator(field).GenerateBuilderMembers(writer);
+      }
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+
+    private void GenerateCommonBuilderMethods(TextGenerator writer) {
+      writer.WriteLine("{0} Builder() {{}}", ClassAccessLevel);
+      writer.WriteLine();
+      writer.WriteLine("{0} result = new {0}();", ClassName);
+      writer.WriteLine();
+      writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName);
+      writer.WriteLine("  get { return result; }");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override Builder Clear() {");
+      writer.WriteLine("  result = new {0}();", ClassName);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override Builder Clone() {");
+      writer.WriteLine("  return new Builder().MergeFrom(result);");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {");
+      writer.WriteLine("  get {{ return {0}.Descriptor; }}", ClassName);
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName);
+      writer.WriteLine("  get {{ return {0}.DefaultInstance; }}", ClassName);
+      writer.WriteLine("}");
+      writer.WriteLine();
+    
+      writer.WriteLine("public override {0} BuildPartial() {{", ClassName);
+      writer.Indent();
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        SourceGenerators.CreateFieldGenerator(field).GenerateBuildingCode(writer);
+      }
+      writer.WriteLine("{0} returnMe = result;", ClassName);
+      writer.WriteLine("result = null;");
+      writer.WriteLine("return returnMe;");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+
+      if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) {
+        writer.WriteLine("public override Builder MergeFrom(pb::IMessage other) {");
+        writer.WriteLine("  if (other is {0}) {{", ClassName);
+        writer.WriteLine("    return MergeFrom(({0}) other);", ClassName);
+        writer.WriteLine("  } else {");
+        writer.WriteLine("    base.MergeFrom(other);");
+        writer.WriteLine("    return this;");
+        writer.WriteLine("  }");
+        writer.WriteLine("}");
+        writer.WriteLine();
+        writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName);
+        // Optimization:  If other is the default instance, we know none of its
+        // fields are set so we can skip the merge.
+        writer.Indent();
+        writer.WriteLine("if (other == {0}.DefaultInstance) return this;", ClassName);
+        foreach (FieldDescriptor field in Descriptor.Fields) {
+          SourceGenerators.CreateFieldGenerator(field).GenerateMergingCode(writer);
+        }
+        writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);");
+        writer.WriteLine("return this;");
+        writer.Outdent();
+        writer.WriteLine("}");
+        writer.WriteLine();
+      }
+    }
+
+    private void GenerateBuilderParsingMethods(TextGenerator writer) {
+      List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields);
+      sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber));
+
+      writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input) {");
+      writer.WriteLine("  return MergeFrom(input, pb::ExtensionRegistry.Empty);");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {");
+      writer.Indent();
+      writer.WriteLine("pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);");
+      writer.WriteLine("while (true) {");
+      writer.Indent();
+      writer.WriteLine("uint tag = input.ReadTag();");
+      writer.WriteLine("switch (tag) {");
+      writer.Indent();
+      writer.WriteLine("case 0: {"); // 0 signals EOF / limit reached
+      writer.WriteLine("  this.UnknownFields = unknownFields.Build();");
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("default: {");
+      writer.WriteLine("  if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {");
+      writer.WriteLine("    this.UnknownFields = unknownFields.Build();");
+      writer.WriteLine("    return this;"); // it's an endgroup tag
+      writer.WriteLine("  }");
+      writer.WriteLine("  break;");
+      writer.WriteLine("}");
+      foreach (FieldDescriptor field in sortedFields) {
+        uint tag = WireFormat.MakeTag(field.FieldNumber, WireFormat.GetWireType(field.FieldType));
+        writer.WriteLine("case {0}: {{", tag);
+        writer.Indent();
+        SourceGenerators.CreateFieldGenerator(field).GenerateParsingCode(writer);
+        writer.WriteLine("break;");
+        writer.Outdent();
+        writer.WriteLine("}");
+      }
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+
+    private void GenerateIsInitialized(TextGenerator writer) {
+      writer.WriteLine("public override bool IsInitialized {");
+      writer.Indent();
+      writer.WriteLine("get {");
+      writer.Indent();
+
+      // Check that all required fields in this message are set.
+      // TODO(kenton):  We can optimize this when we switch to putting all the
+      // "has" fields into a single bitfield.
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        if (field.IsRequired) {
+          writer.WriteLine("if (!has{0}) return false;", Helpers.UnderscoresToPascalCase(field.Name));
+        }
+      }
+  
+      // Now check that all embedded messages are initialized.
+      foreach (FieldDescriptor field in Descriptor.Fields) {
+        if (field.FieldType != FieldType.Message ||
+            !HasRequiredFields(field.MessageType, new Dictionary<MessageDescriptor, object>())) {
+          continue;
+        }
+        string propertyName = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field));
+        if (field.IsRepeated) {
+          writer.WriteLine("foreach ({0} element in {1}List) {{", DescriptorUtil.GetClassName(field.MessageType), propertyName);
+          writer.WriteLine("  if (!element.IsInitialized) return false;");
+          writer.WriteLine("}");
+        } else if (field.IsOptional) {
+          writer.WriteLine("if (Has{0}) {{", propertyName);
+          writer.WriteLine("  if (!{0}.IsInitialized) return false;", propertyName);
+          writer.WriteLine("}");
+        } else {
+          writer.WriteLine("if (!{0}.IsInitialized) return false;", propertyName);
+        }
+      }
+
+      if (Descriptor.Extensions.Count > 0) {
+        writer.WriteLine("if (!ExtensionsAreInitialized) return false;");
+      }
+      writer.WriteLine("return true;");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+  }
+}
diff --git a/csharp/ProtoGen/PrimitiveFieldGenerator.cs b/csharp/ProtoGen/PrimitiveFieldGenerator.cs
new file mode 100644
index 00000000..9107def9
--- /dev/null
+++ b/csharp/ProtoGen/PrimitiveFieldGenerator.cs
@@ -0,0 +1,70 @@
+using System;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  // TODO(jonskeet): Refactor this. There's loads of common code here.
+  internal class PrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+
+    internal PrimitiveFieldGenerator(FieldDescriptor descriptor)
+        : base(descriptor) {
+    }
+
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private bool has{0};", CapitalizedName);
+      writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue);
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine("  get {{ return has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
+      writer.WriteLine("  get {{ return {0}_; }}", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      writer.WriteLine("public bool Has{0} {{", CapitalizedName);
+      writer.WriteLine("  get {{ return result.Has{0}; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} {1} {{", TypeName, PropertyName);
+      writer.WriteLine("  get {{ return result.{0}; }}", PropertyName);
+      writer.WriteLine("  set {{ Set{0}(value); }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.has{0} = true;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.has{0} = false;", CapitalizedName);
+      writer.WriteLine("  result.{0}_ = {1};", Name, DefaultValue);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  {0} = other.{0};", PropertyName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      // Nothing to do here for primitive types
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      writer.WriteLine("{0} = input.Read{1}();", PropertyName, CapitalizedTypeName);
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  output.Write{0}({1}, {2});", CapitalizedTypeName, Number, PropertyName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("if (Has{0}) {{", CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.Compute{0}Size({1}, {2});",
+          CapitalizedTypeName, Number, PropertyName);
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/Program.cs b/csharp/ProtoGen/Program.cs
index 22245ab8..08cad358 100644
--- a/csharp/ProtoGen/Program.cs
+++ b/csharp/ProtoGen/Program.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Google.ProtocolBuffers.DescriptorProtos;
 
 namespace Google.ProtocolBuffers.ProtoGen {
   /// <summary>
@@ -8,7 +9,8 @@ namespace Google.ProtocolBuffers.ProtoGen {
   class Program {
     static int Main(string[] args) {
       try {
-
+        // Hack to make sure everything's initialized
+        DescriptorProtoFile.Descriptor.ToString();
         GeneratorOptions options = ParseCommandLineArguments(args);
 
         IList<string> validationFailures;
@@ -25,16 +27,20 @@ namespace Google.ProtocolBuffers.ProtoGen {
 
         return 0;
       } catch (Exception e) {
-        Console.Error.WriteLine("Caught unhandled exception: {0}", e);
+        Console.Error.WriteLine("Error: {0}", e.Message);
+        Console.Error.WriteLine();
+        Console.Error.WriteLine("Detailed exception information: {0}", e);
         return 1;
       }
     }
 
     private static GeneratorOptions ParseCommandLineArguments(string[] args) {
       GeneratorOptions options = new GeneratorOptions();
-      string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers";
-      options.OutputDirectory = baseDir + "\\tmp";
-      options.InputFiles = new[] { baseDir + "\\protos\\nwind.protobin" };
+      //string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers";
+      //options.OutputDirectory = baseDir + "\\tmp";
+      //options.InputFiles = new[] { baseDir + "\\protos\\nwind-solo.protobin" };
+      options.OutputDirectory = ".";
+      options.InputFiles = args;
       return options;
     }
   }
diff --git a/csharp/ProtoGen/ProtoGen.csproj b/csharp/ProtoGen/ProtoGen.csproj
index b4d06c50..f48df42c 100644
--- a/csharp/ProtoGen/ProtoGen.csproj
+++ b/csharp/ProtoGen/ProtoGen.csproj
@@ -38,12 +38,31 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DescriptorUtil.cs" />
+    <Compile Include="EnumFieldGenerator.cs" />
+    <Compile Include="EnumGenerator.cs" />
+    <Compile Include="ExtensionGenerator.cs" />
+    <Compile Include="FieldGeneratorBase.cs" />
+    <Compile Include="IFieldSourceGenerator.cs" />
+    <Compile Include="ISourceGenerator.cs" />
+    <Compile Include="MessageFieldGenerator.cs" />
+    <Compile Include="MessageGenerator.cs" />
+    <Compile Include="PrimitiveFieldGenerator.cs" />
+    <Compile Include="RepeatedEnumFieldGenerator.cs" />
+    <Compile Include="RepeatedMessageFieldGenerator.cs" />
+    <Compile Include="RepeatedPrimitiveFieldGenerator.cs" />
+    <Compile Include="ServiceGenerator.cs" />
+    <Compile Include="SourceFileGenerator.cs" />
     <Compile Include="DependencyResolutionException.cs" />
     <Compile Include="Generator.cs" />
     <Compile Include="GeneratorOptions.cs" />
+    <Compile Include="Helpers.cs" />
     <Compile Include="InvalidOptionsException.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SourceGeneratorBase.cs" />
+    <Compile Include="SourceGenerators.cs" />
+    <Compile Include="UmbrellaClassGenerator.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />
diff --git a/csharp/ProtoGen/ProtoGen.csproj.user b/csharp/ProtoGen/ProtoGen.csproj.user
new file mode 100644
index 00000000..ae26d4a2
--- /dev/null
+++ b/csharp/ProtoGen/ProtoGen.csproj.user
@@ -0,0 +1,6 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <StartWorkingDirectory>c:\Users\Jon\Documents\Visual Studio 2008\Projects\ProtocolBuffers\csharp\testprotos</StartWorkingDirectory>
+    <StartArguments>unittest.protobin</StartArguments>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/csharp/ProtoGen/RepeatedEnumFieldGenerator.cs b/csharp/ProtoGen/RepeatedEnumFieldGenerator.cs
new file mode 100644
index 00000000..088045f7
--- /dev/null
+++ b/csharp/ProtoGen/RepeatedEnumFieldGenerator.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class RepeatedEnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+
+    internal RepeatedEnumFieldGenerator(FieldDescriptor descriptor)
+      : base(descriptor) {
+    }
+
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
+      writer.WriteLine("}");
+
+      // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return {0}_.Count; }}", Name);
+      writer.WriteLine("}");
+
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return {0}_[index];", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      // Note:  We can return the original list here, because we make it unmodifiable when we build
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}_; }}", Name);
+      writer.WriteLine("}");
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}Count; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return result.Get{0}(index);", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_[index] = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_.Add(value);", Name, TypeName);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  base.AddRange(values, result.{0}_);", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.{0}_.Clear();", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
+      writer.WriteLine("  base.AddRange(other.{0}_, result.{0}_);", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      // TODO(jonskeet): Make a more efficient way of doing this
+      writer.WriteLine("int rawValue = input.ReadEnum();");
+      writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName);
+      writer.WriteLine("  unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number);
+      writer.WriteLine("} else {");
+      writer.WriteLine("  Add{0}({1} rawValue);", CapitalizedName, TypeName);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  output.WriteEnum({0}, (int) element);", Number);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) element);", Number);
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/RepeatedMessageFieldGenerator.cs b/csharp/ProtoGen/RepeatedMessageFieldGenerator.cs
new file mode 100644
index 00000000..08d574a9
--- /dev/null
+++ b/csharp/ProtoGen/RepeatedMessageFieldGenerator.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class RepeatedMessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+
+    internal RepeatedMessageFieldGenerator(FieldDescriptor descriptor)
+      : base(descriptor) {
+    }
+    
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return {0}_; }}", Name);
+      writer.WriteLine("}");
+
+      // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return {0}_.Count; }}", Name);
+      writer.WriteLine("}");
+
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return {0}_[index];", Name);
+      writer.WriteLine("}");
+    }    
+
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      // Note:  We can return the original list here, because we make it unmodifiable when we build
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}_; }}", Name);
+      writer.WriteLine("}");
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}Count; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return result.Get{0}(index);", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_[index] = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      // Extra overload for builder (just on messages)
+      writer.WriteLine("public Builder Set{0}(int index, {1}.Builder builderForValue) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_[index] = builderForValue.Build();", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_.Add(value);", Name, TypeName);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      // Extra overload for builder (just on messages)
+      writer.WriteLine("public Builder Add{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_.Add(builderForValue.Build());", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  base.AddRange(values, result.{0}_);", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.{0}_.Clear();", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }    
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
+      writer.WriteLine("  base.AddRange(other.{0}_, result.{0}_);", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName);
+      if (Descriptor.FieldType == FieldType.Group) {
+        writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number);
+      } else {
+        writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);");
+      }
+      writer.WriteLine("Add{0}(subBuilder.BuildPartial());", CapitalizedName);
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  output.Write{0}({1}, element);", MessageOrGroup, Number);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.Compute{0}Size({1}, element);", MessageOrGroup, Number);
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/RepeatedPrimitiveFieldGenerator.cs b/csharp/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
new file mode 100644
index 00000000..cdb7cd6f
--- /dev/null
+++ b/csharp/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class RepeatedPrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator {
+
+    internal RepeatedPrimitiveFieldGenerator(FieldDescriptor descriptor)
+      : base(descriptor) {
+    }
+
+    public void GenerateMembers(TextGenerator writer) {
+      writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name);
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name);
+      writer.WriteLine("}");
+
+      // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option.
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return {0}_.Count; }}", Name);
+      writer.WriteLine("}");
+
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return {0}_[index];", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuilderMembers(TextGenerator writer) {
+      // Note:  We can return the original list here, because we make it unmodifiable when we build
+      writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}_; }}", Name);
+      writer.WriteLine("}");
+      writer.WriteLine("public int {0}Count {{", CapitalizedName);
+      writer.WriteLine("  get {{ return result.{0}Count; }}", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  return result.Get{0}(index);", CapitalizedName);
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_[index] = value;", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  result.{0}_.Add(value);", Name, TypeName);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName);
+      writer.WriteLine("  base.AddRange(values, result.{0}_);", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+      writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName);
+      writer.WriteLine("  result.{0}_.Clear();", Name);
+      writer.WriteLine("  return this;");
+      writer.WriteLine("}");
+    }
+
+    public void GenerateMergingCode(TextGenerator writer) {
+      writer.WriteLine("if (other.{0}_.Count != 0) {{", Name);
+      writer.WriteLine("  base.AddRange(other.{0}_, result.{0}_);", Name);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateBuildingCode(TextGenerator writer) {
+      writer.WriteLine("result.{0}_.MakeReadOnly();", Name);
+    }
+
+    public void GenerateParsingCode(TextGenerator writer) {
+      writer.WriteLine("Add{0}(input.Read{1}());", CapitalizedName, CapitalizedTypeName);
+    }
+
+    public void GenerateSerializationCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  output.Write{0}({1}, element);", CapitalizedTypeName, Number);
+      writer.WriteLine("}");
+    }
+
+    public void GenerateSerializedSizeCode(TextGenerator writer) {
+      writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName);
+      writer.WriteLine("  size += pb::CodedOutputStream.Compute{0}Size({1}, element);", CapitalizedTypeName, Number);
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/ServiceGenerator.cs b/csharp/ProtoGen/ServiceGenerator.cs
new file mode 100644
index 00000000..9b642b74
--- /dev/null
+++ b/csharp/ProtoGen/ServiceGenerator.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal class ServiceGenerator : SourceGeneratorBase<ServiceDescriptor>, ISourceGenerator {
+
+    private enum RequestOrResponse {
+      Request,
+      Response
+    }
+
+    internal ServiceGenerator(ServiceDescriptor descriptor)
+      : base(descriptor) {
+    }
+
+    public void Generate(TextGenerator writer) {
+      writer.WriteLine("{0} abstract class {1} : pb::IService {{", ClassAccessLevel, Descriptor.Name);
+      writer.Indent();
+
+      foreach (MethodDescriptor method in Descriptor.Methods) {
+        writer.WriteLine("{0} abstract void {1}(", ClassAccessLevel, Helpers.UnderscoresToPascalCase(method.Name));
+        writer.WriteLine("    pb::IRpcController controller,");
+        writer.WriteLine("    {0} request,", DescriptorUtil.GetClassName(method.InputType));
+        writer.WriteLine("    global::System.Action<{0}> done);", DescriptorUtil.GetClassName(method.OutputType));
+      }
+
+      // Generate Descriptor and DescriptorForType.
+      writer.WriteLine();
+      writer.WriteLine("{0} static pbd::ServiceDescriptor Descriptor {{", ClassAccessLevel);
+      writer.WriteLine("  get {{ return {0}.Descriptor.Services[{1}]; }}",
+          DescriptorUtil.GetUmbrellaClassName(Descriptor.File), Descriptor.Index);
+      writer.WriteLine("}");
+      writer.WriteLine("{0} pbd::ServiceDescriptor DescriptorForType {{", ClassAccessLevel);
+      writer.WriteLine("  get { return Descriptor; }");
+      writer.WriteLine("}");
+
+      GenerateCallMethod(writer);
+      GenerateGetPrototype(RequestOrResponse.Request, writer);
+      GenerateGetPrototype(RequestOrResponse.Response, writer);
+      GenerateStub(writer);
+
+      writer.Outdent();
+      writer.WriteLine("}");
+    }
+
+    private void GenerateCallMethod(TextGenerator writer) {
+      writer.WriteLine();
+      writer.WriteLine("public void CallMethod(", ClassAccessLevel);
+      writer.WriteLine("    pbd::MethodDescriptor method,");
+      writer.WriteLine("    pb::IRpcController controller,");
+      writer.WriteLine("    pb::IMessage request,");
+      writer.WriteLine("    global::System.Action<pb::IMessage> done) {");
+      writer.Indent();
+      writer.WriteLine("if (method.Service != Descriptor) {");
+      writer.WriteLine("  throw new global::System.ArgumentException(");
+      writer.WriteLine("      \"Service.CallMethod() given method descriptor for wrong service type.\");");
+      writer.WriteLine("}");
+      writer.WriteLine("switch(method.Index) {");
+      writer.Indent();
+      foreach (MethodDescriptor method in Descriptor.Methods) {
+        writer.WriteLine("case {0}:", method.Index);
+        writer.WriteLine("  this.{0}(controller, ({0}) request,",
+            Helpers.UnderscoresToPascalCase(method.Name), DescriptorUtil.GetClassName(method.InputType));
+        writer.WriteLine("      pb::RpcUtil.SpecializeCallback<{0}>(", DescriptorUtil.GetClassName(method.OutputType));
+        writer.WriteLine("      done));");
+        writer.WriteLine("  return;");
+      }
+      writer.WriteLine("default:");
+      writer.WriteLine("  throw new global::System.InvalidOperationException(\"Can't get here.\");");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+
+    private void GenerateGetPrototype(RequestOrResponse which, TextGenerator writer) {
+      writer.WriteLine("public pb::IMessage Get{0}Prototype(pbd::MethodDescriptor method) {{", which);
+      writer.Indent();
+      writer.WriteLine("if (method.Service != Descriptor) {");
+      writer.WriteLine("  throw new global::System.ArgumentException(");
+      writer.WriteLine("      \"Service.Get{0}Prototype() given method descriptor for wrong service type.\");", which);
+      writer.WriteLine("}");
+      writer.WriteLine("switch(method.Index) {");
+      writer.Indent();
+
+      foreach (MethodDescriptor method in Descriptor.Methods) {
+        writer.WriteLine("case {0}:", method.Index);
+        writer.WriteLine("  return {0}.DefaultInstance;", 
+          DescriptorUtil.GetClassName(which == RequestOrResponse.Request ? method.InputType : method.OutputType));
+      }
+      writer.WriteLine("default:");
+      writer.WriteLine("  throw new global::System.InvalidOperationException(\"Can't get here.\");");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.Outdent();
+      writer.WriteLine("}");
+      writer.WriteLine();
+    }
+
+    private void GenerateStub(TextGenerator writer) {
+      writer.WriteLine("public static Stub CreateStub(pb::IRpcChannel channel) {");
+      writer.WriteLine("  return new Stub(channel);");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("{0} class Stub : {1} {{", ClassAccessLevel, DescriptorUtil.GetClassName(Descriptor));
+      writer.Indent();
+      writer.WriteLine("internal Stub(pb::IRpcChannel channel) {");
+      writer.WriteLine("  this.channel = channel;");
+      writer.WriteLine("}");
+      writer.WriteLine();
+      writer.WriteLine("private readonly pb::IRpcChannel channel;");
+      writer.WriteLine();
+      writer.WriteLine("public pb::IRpcChannel Channel {");
+      writer.WriteLine("  get { return channel; }");
+      writer.WriteLine("}");
+
+      foreach (MethodDescriptor method in Descriptor.Methods) {
+        writer.WriteLine();
+        writer.WriteLine("public override void {0}(", Helpers.UnderscoresToPascalCase(method.Name));
+        writer.WriteLine("    pb::IRpcController controller,");
+        writer.WriteLine("    {0} request,", DescriptorUtil.GetClassName(method.InputType));
+        writer.WriteLine("    global::System.Action<{0}> done) {{", DescriptorUtil.GetClassName(method.OutputType));
+        writer.Indent();
+        writer.WriteLine("channel.CallMethod(Descriptor.Methods[{0}],", method.Index);
+        writer.WriteLine("    controller, request, {0}.DefaultInstance,", DescriptorUtil.GetClassName(method.OutputType));
+        writer.WriteLine("    pb::RpcUtil.GeneralizeCallback<{0}, {0}.Builder>(done, {0}.DefaultInstance));",
+            DescriptorUtil.GetClassName(method.OutputType));
+        writer.Outdent();
+        writer.WriteLine("}");
+      }
+      writer.Outdent();
+      writer.WriteLine("}");
+    }
+  }
+}
diff --git a/csharp/ProtoGen/SourceFileGenerator.cs b/csharp/ProtoGen/SourceFileGenerator.cs
new file mode 100644
index 00000000..1984d297
--- /dev/null
+++ b/csharp/ProtoGen/SourceFileGenerator.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  /// <summary>
+  /// Generator to hold a TextGenerator, generate namespace aliases etc.
+  /// Each source file created uses one of these, and it can be used to create
+  /// multiple classes within the same file.
+  /// </summary>
+  internal class SourceFileGenerator  {
+
+    private readonly TextGenerator output;
+
+    private SourceFileGenerator(TextWriter writer) {
+      output = new TextGenerator(writer);
+    }
+
+    /// <summary>
+    /// Creates a ClassFileGenerator for the given writer, which will be closed
+    /// when the instance is disposed. The specified namespace is created, if it's non-null.
+    /// </summary>
+    internal static SourceFileGenerator ForWriter(TextWriter writer) {
+      return new SourceFileGenerator(writer);
+    }
+  }
+}
diff --git a/csharp/ProtoGen/SourceGeneratorBase.cs b/csharp/ProtoGen/SourceGeneratorBase.cs
new file mode 100644
index 00000000..563c64a1
--- /dev/null
+++ b/csharp/ProtoGen/SourceGeneratorBase.cs
@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using Google.ProtocolBuffers.DescriptorProtos;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal abstract class SourceGeneratorBase<T> where T : IDescriptor {
+
+    private readonly T descriptor;
+
+    protected SourceGeneratorBase(T descriptor) {
+      this.descriptor = descriptor;
+    }
+
+    protected T Descriptor {
+      get { return descriptor; }
+    }
+
+    protected string ClassAccessLevel {
+      get { 
+        // Default to public
+        return !descriptor.File.Options.HasExtension(CSharpOptions.CSharpPublicClasses)
+            || descriptor.File.Options.GetExtension(CSharpOptions.CSharpPublicClasses) ? "public" : "internal";
+      }
+    }
+
+    public bool MultipleFiles {
+      get { return descriptor.File.Options.GetExtension(CSharpOptions.CSharpMultipleFiles); }
+    }
+
+    protected static void WriteChildren<TChild>(TextGenerator writer, string region, IEnumerable<TChild> children) 
+        where TChild : IDescriptor {
+      // Copy the set of children; makes access easier
+      List<TChild> copy = new List<TChild>(children);
+      if (copy.Count == 0) {
+        return;
+      }
+
+      if (region != null) {
+        writer.WriteLine("#region {0}", region);
+      }
+      foreach (TChild child in children) {
+        SourceGenerators.CreateGenerator(child).Generate(writer);
+      }
+      if (region != null) {
+        writer.WriteLine("#endregion");
+        writer.WriteLine();
+      }
+    }
+  }
+}
diff --git a/csharp/ProtoGen/SourceGenerators.cs b/csharp/ProtoGen/SourceGenerators.cs
new file mode 100644
index 00000000..c775e419
--- /dev/null
+++ b/csharp/ProtoGen/SourceGenerators.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  internal static class SourceGenerators {
+
+    private static readonly Dictionary<Type, Func<IDescriptor, ISourceGenerator>> GeneratorFactories = new Dictionary<Type, Func<IDescriptor, ISourceGenerator>> {
+      { typeof(FileDescriptor), descriptor => new UmbrellaClassGenerator((FileDescriptor) descriptor) },
+      { typeof(EnumDescriptor), descriptor => new EnumGenerator((EnumDescriptor) descriptor) },
+      { typeof(ServiceDescriptor), descriptor => new ServiceGenerator((ServiceDescriptor) descriptor) },
+      { typeof(MessageDescriptor), descriptor => new MessageGenerator((MessageDescriptor) descriptor) },
+      // For other fields, we have IFieldSourceGenerators.
+      { typeof(FieldDescriptor), descriptor => new ExtensionGenerator((FieldDescriptor) descriptor) }
+    };
+
+    public static IFieldSourceGenerator CreateFieldGenerator(FieldDescriptor field) {
+      switch (field.MappedType) {
+        case MappedType.Message :
+          return field.IsRepeated 
+              ? (IFieldSourceGenerator) new RepeatedMessageFieldGenerator(field)
+              : new MessageFieldGenerator(field);
+        case MappedType.Enum:
+          return field.IsRepeated
+              ? (IFieldSourceGenerator)new RepeatedEnumFieldGenerator(field)
+              : new EnumFieldGenerator(field);
+        default:
+          return field.IsRepeated
+              ? (IFieldSourceGenerator)new RepeatedPrimitiveFieldGenerator(field)
+              : new PrimitiveFieldGenerator(field);
+      }
+    }
+
+    public static ISourceGenerator CreateGenerator<T>(T descriptor) where T : IDescriptor {
+      Func<IDescriptor, ISourceGenerator> factory;
+      if (!GeneratorFactories.TryGetValue(typeof(T), out factory)) {
+        throw new ArgumentException("No generator registered for " + typeof(T).Name);
+      }
+      return factory(descriptor);
+    }
+  }
+}
diff --git a/csharp/ProtoGen/UmbrellaClassGenerator.cs b/csharp/ProtoGen/UmbrellaClassGenerator.cs
new file mode 100644
index 00000000..7db5c46c
--- /dev/null
+++ b/csharp/ProtoGen/UmbrellaClassGenerator.cs
@@ -0,0 +1,96 @@
+using System;
+using Google.ProtocolBuffers.DescriptorProtos;
+using Google.ProtocolBuffers.Descriptors;
+
+namespace Google.ProtocolBuffers.ProtoGen {
+  /// <summary>
+  /// Generator for the class describing the .proto file in general,
+  /// containing things like the message descriptor.
+  /// </summary>
+  internal sealed class UmbrellaClassGenerator : SourceGeneratorBase<FileDescriptor>, ISourceGenerator {
+
+    internal UmbrellaClassGenerator(FileDescriptor descriptor)
+      : base(descriptor) {
+    }
+
+    public void Generate(TextGenerator writer) {
+      WriteIntroduction(writer);
+      WriteDescriptor(writer);
+      WriteChildren(writer, "Extensions", Descriptor.Extensions);
+      writer.WriteLine("#region Static variables");
+      foreach (MessageDescriptor message in Descriptor.MessageTypes) {
+        new MessageGenerator(message).GenerateStaticVariables(writer);
+      }
+      writer.WriteLine("#endregion");
+      // The class declaration either gets closed before or after the children are written.
+      if (!DescriptorUtil.NestClasses(Descriptor)) {
+        writer.Outdent();
+        writer.WriteLine("}");
+      }
+      WriteChildren(writer, "Enums", Descriptor.EnumTypes);
+      WriteChildren(writer, "Messages", Descriptor.MessageTypes);
+      WriteChildren(writer, "Services", Descriptor.Services);
+      if (DescriptorUtil.NestClasses(Descriptor)) {
+        writer.Outdent();
+        writer.WriteLine("}");
+      }
+      if (DescriptorUtil.GetNamespace(Descriptor) != "") {
+        writer.Outdent();
+        writer.WriteLine("}");
+      }
+    }
+
+    private void WriteIntroduction(TextGenerator writer) {
+      writer.WriteLine("// Generated by the protocol buffer compiler.  DO NOT EDIT!");
+      writer.WriteLine();
+      Helpers.WriteNamespaces(writer);
+
+      if (DescriptorUtil.GetNamespace(Descriptor) != "") {
+        writer.WriteLine("namespace {0} {{", DescriptorUtil.GetNamespace(Descriptor));
+        writer.Indent();
+        writer.WriteLine();
+      }
+
+      writer.WriteLine("{0} static partial class {1} {{", ClassAccessLevel, DescriptorUtil.GetUmbrellaClassName(Descriptor));
+      writer.WriteLine();
+      writer.Indent();
+    }
+
+    private void WriteDescriptor(TextGenerator writer) {
+      writer.WriteLine("#region Descriptor");
+
+      writer.WriteLine("public static pbd::FileDescriptor Descriptor {");
+      writer.WriteLine("  get { return descriptor; }");
+      writer.WriteLine("}");
+      writer.WriteLine("private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(");
+      writer.WriteLine("    global::System.Convert.FromBase64String(");
+      writer.Indent();
+      writer.Indent();
+
+      // TODO(jonskeet): Consider a C#-escaping format here instead of just Base64.
+      byte[] bytes = Descriptor.Proto.ToByteArray();
+      string base64 = Convert.ToBase64String(bytes);
+
+      while (base64.Length > 60) {
+        writer.WriteLine("\"{0}\" + ", base64.Substring(0, 60));
+        base64 = base64.Substring(60);
+      }
+      writer.WriteLine("\"{0}\"),", base64);
+
+      writer.WriteLine("new pbd::FileDescriptor[] {");
+      foreach (FileDescriptor dependency in Descriptor.Dependencies) {
+        // TODO(jonskeet): The normal code won't work for the bootstrapping descriptor, because we don't get unknown fields :(
+        if (dependency.Package == "google.protobuf" && dependency.Name.EndsWith("descriptor.proto")) {
+          writer.WriteLine("  global::" + typeof(DescriptorProtoFile).FullName + ".Descriptor, ");
+          continue;
+        }
+        writer.WriteLine("  {0}.Descriptor, ", DescriptorUtil.GetFullUmbrellaClassName(dependency));
+      }
+      writer.WriteLine("});");
+      writer.Outdent();
+      writer.Outdent();
+      writer.WriteLine("#endregion");
+      writer.WriteLine();
+    }
+  }
+}
diff --git a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs
index 7d8d1d0e..f4314b30 100644
--- a/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs
+++ b/csharp/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs
@@ -10,40 +10,31 @@ namespace Google.ProtocolBuffers.TestProtos {
   
     #region Descriptor
     public static pbd::FileDescriptor Descriptor {
-        get { return descriptor; }
-    }
-    private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom (
-        new byte[] {
-            0x0a, 0x25, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x75, 0x6e, 
-            0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 
-            0x18, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 
-            0x6d, 0x70, 0x6f, 0x72, 0x74, 0x22, 0x1a, 0x0a, 0x0d, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 
-            0x67, 0x65, 0x12, 0x09, 0x0a, 0x01, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x2a, 0x3c, 0x0a, 0x0a, 0x49, 0x6d, 0x70, 
-            0x6f, 0x72, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x4d, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x46, 0x4f, 
-            0x4f, 0x10, 0x07, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x4d, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x41, 0x52, 0x10, 0x08, 0x12, 
-            0x0e, 0x0a, 0x0a, 0x49, 0x4d, 0x50, 0x4f, 0x52, 0x54, 0x5f, 0x42, 0x41, 0x5a, 0x10, 0x09, 0x42, 0x5a, 0x0a, 0x18, 0x63, 
-            0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x74, 
-            0x65, 0x73, 0x74, 0x48, 0x01, 0xc2, 0x3e, 0x21, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 
-            0x63, 0x6f, 0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 
-            0x73, 0xca, 0x3e, 0x17, 0x55, 0x6e, 0x69, 0x74, 0x54, 0x65, 0x73, 0x74, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 
-            0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 
-        }, new pbd::FileDescriptor[] {
+      get { return descriptor; }
+    }
+    private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
+        global::System.Convert.FromBase64String(
+        "ChV1bml0dGVzdF9pbXBvcnQucHJvdG8SGHByb3RvYnVmX3VuaXR0ZXN0X2lt" + 
+        "cG9ydBokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25zLnByb3RvGiBn" + 
+        "b29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90byIaCg1JbXBvcnRNZXNz" + 
+        "YWdlEgkKAWQYASABKAUqPAoKSW1wb3J0RW51bRIOCgpJTVBPUlRfRk9PEAcS" + 
+        "DgoKSU1QT1JUX0JBUhAIEg4KCklNUE9SVF9CQVoQCUJcChhjb20uZ29vZ2xl" + 
+        "LnByb3RvYnVmLnRlc3RIAYLiCSFHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRl" + 
+        "c3RQcm90b3OK4gkXVW5pdFRlc3RJbXBvcnRQcm90b0ZpbGU="),
+        new pbd::FileDescriptor[] {
+          global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, 
+          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, 
         });
     #endregion
     
-    #region Extensions
-    #endregion
-    
     #region Static variables
-    internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_import_ImportMessage__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_import_ImportMessage__Descriptor
         = Descriptor.MessageTypes[0];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder> internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder>(internal__static_protobuf_unittest_import_ImportMessage__Descriptor,
             new string[] { "D", });
     #endregion
-    
   }
-  
   #region Enums
   public enum ImportEnum {
     IMPORT_FOO = 7,
@@ -76,7 +67,6 @@ namespace Google.ProtocolBuffers.TestProtos {
       get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable; }
     }
     
-    // optional int32 d = 1;
     private bool hasD;
     private int d_ = 0;
     public bool HasD {
@@ -115,62 +105,50 @@ namespace Google.ProtocolBuffers.TestProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(pb::ByteString data) {
+    public static ImportMessage ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ImportMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(byte[] data) {
+    public static ImportMessage ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ImportMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(global::System.IO.Stream input) {
+    public static ImportMessage ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ImportMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(pb::CodedInputStream input) {
+    public static ImportMessage ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.TestProtos.ImportMessage ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ImportMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.TestProtos.ImportMessage prototype) {
+    public static Builder CreateBuilder(ImportMessage prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.TestProtos.ImportMessage, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<ImportMessage, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.TestProtos.ImportMessage result = new global::Google.ProtocolBuffers.TestProtos.ImportMessage();
+      ImportMessage result = new ImportMessage();
       
-      protected override global::Google.ProtocolBuffers.TestProtos.ImportMessage MessageBeingBuilt {
+      protected override ImportMessage MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.TestProtos.ImportMessage();
+        result = new ImportMessage();
         return this;
       }
       
@@ -179,30 +157,30 @@ namespace Google.ProtocolBuffers.TestProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.TestProtos.ImportMessage.Descriptor; }
+        get { return ImportMessage.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.TestProtos.ImportMessage DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance; }
+      public override ImportMessage DefaultInstanceForType {
+        get { return ImportMessage.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.TestProtos.ImportMessage BuildPartial() {
-        global::Google.ProtocolBuffers.TestProtos.ImportMessage returnMe = result;
+      public override ImportMessage BuildPartial() {
+        ImportMessage returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.TestProtos.ImportMessage) {
-          return MergeFrom((global::Google.ProtocolBuffers.TestProtos.ImportMessage) other);
+        if (other is ImportMessage) {
+          return MergeFrom((ImportMessage) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.TestProtos.ImportMessage other) {
-        if (other == global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance) return this;
+      public override Builder MergeFrom(ImportMessage other) {
+        if (other == ImportMessage.DefaultInstance) return this;
         if (other.HasD) {
           D = other.D;
         }
@@ -215,17 +193,16 @@ namespace Google.ProtocolBuffers.TestProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -240,7 +217,6 @@ namespace Google.ProtocolBuffers.TestProtos {
       }
       
       
-      // optional int32 d = 1;
       public bool HasD {
         get { return result.HasD; }
       }
@@ -263,6 +239,4 @@ namespace Google.ProtocolBuffers.TestProtos {
   
   #endregion
   
-  #region Services
-  #endregion
 }
diff --git a/csharp/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs b/csharp/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
new file mode 100644
index 00000000..14d6bb64
--- /dev/null
+++ b/csharp/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs
@@ -0,0 +1,49 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+
+using pb = global::Google.ProtocolBuffers;
+using pbc = global::Google.ProtocolBuffers.Collections;
+using pbd = global::Google.ProtocolBuffers.Descriptors;
+using scg = global::System.Collections.Generic;
+namespace Google.ProtocolBuffers.DescriptorProtos {
+  
+  public static partial class CSharpOptions {
+  
+    #region Descriptor
+    public static pbd::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
+        global::System.Convert.FromBase64String(
+        "CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" + 
+        "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG86" + 
+        "NwoPQ1NoYXJwTmFtZXNwYWNlEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRp" + 
+        "b25zGKCcASABKAk6PwoXQ1NoYXJwVW1icmVsbGFDbGFzc25hbWUSHC5nb29n" + 
+        "bGUucHJvdG9idWYuRmlsZU9wdGlvbnMYoZwBIAEoCTo7ChNDU2hhcnBNdWx0" + 
+        "aXBsZUZpbGVzEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKKcASAB" + 
+        "KAg6OQoRQ1NoYXJwTmVzdENsYXNzZXMSHC5nb29nbGUucHJvdG9idWYuRmls" + 
+        "ZU9wdGlvbnMYo5wBIAEoCDo7ChNDU2hhcnBQdWJsaWNDbGFzc2VzEhwuZ29v" + 
+        "Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKScASABKAhCPILiCSdHb29nbGUu" + 
+        "UHJvdG9jb2xCdWZmZXJzLkRlc2NyaXB0b3JQcm90b3OK4gkNQ1NoYXJwT3B0" + 
+        "aW9ucw=="),
+        new pbd::FileDescriptor[] {
+          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, 
+        });
+    #endregion
+    
+    #region Extensions
+    public static readonly pb::GeneratedExtensionBase<string> CSharpNamespace =
+        pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[0]);
+    public static readonly pb::GeneratedExtensionBase<string> CSharpUmbrellaClassname =
+        pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[1]);
+    public static readonly pb::GeneratedExtensionBase<bool> CSharpMultipleFiles =
+        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[2]);
+    public static readonly pb::GeneratedExtensionBase<bool> CSharpNestClasses =
+        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[3]);
+    public static readonly pb::GeneratedExtensionBase<bool> CSharpPublicClasses =
+        pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[4]);
+    #endregion
+    
+    #region Static variables
+    #endregion
+  }
+}
diff --git a/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
index 488b0c60..1a7c9a1f 100644
--- a/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
+++ b/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
@@ -10,249 +10,184 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
   
     #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, 0x47, 0x0a, 0x11, 0x46, 0x69, 0x6c, 0x65, 0x44, 
-            0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x53, 0x65, 0x74, 0x12, 0x32, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 
-            0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 
-            0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 
-            0x72, 0x6f, 0x74, 0x6f, 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[] {
+      get { return descriptor; }
+    }
+    private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom(
+        global::System.Convert.FromBase64String(
+        "CiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxIPZ29vZ2xlLnBy" + 
+        "b3RvYnVmIkcKEUZpbGVEZXNjcmlwdG9yU2V0EjIKBGZpbGUYASADKAsyJC5n" + 
+        "b29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90byLcAgoTRmlsZURl" + 
+        "c2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg8KB3BhY2thZ2UYAiABKAkS" + 
+        "EgoKZGVwZW5kZW5jeRgDIAMoCRI2CgxtZXNzYWdlX3R5cGUYBCADKAsyIC5n" + 
+        "b29nbGUucHJvdG9idWYuRGVzY3JpcHRvclByb3RvEjcKCWVudW1fdHlwZRgF" + 
+        "IAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5FbnVtRGVzY3JpcHRvclByb3RvEjgK" + 
+        "B3NlcnZpY2UYBiADKAsyJy5nb29nbGUucHJvdG9idWYuU2VydmljZURlc2Ny" + 
+        "aXB0b3JQcm90bxI4CglleHRlbnNpb24YByADKAsyJS5nb29nbGUucHJvdG9i" + 
+        "dWYuRmllbGREZXNjcmlwdG9yUHJvdG8SLQoHb3B0aW9ucxgIIAEoCzIcLmdv" + 
+        "b2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucyKpAwoPRGVzY3JpcHRvclByb3Rv" + 
+        "EgwKBG5hbWUYASABKAkSNAoFZmllbGQYAiADKAsyJS5nb29nbGUucHJvdG9i" + 
+        "dWYuRmllbGREZXNjcmlwdG9yUHJvdG8SOAoJZXh0ZW5zaW9uGAYgAygLMiUu" + 
+        "Z29vZ2xlLnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvEjUKC25lc3Rl" + 
+        "ZF90eXBlGAMgAygLMiAuZ29vZ2xlLnByb3RvYnVmLkRlc2NyaXB0b3JQcm90" + 
+        "bxI3CgllbnVtX3R5cGUYBCADKAsyJC5nb29nbGUucHJvdG9idWYuRW51bURl" + 
+        "c2NyaXB0b3JQcm90bxJICg9leHRlbnNpb25fcmFuZ2UYBSADKAsyLy5nb29n" + 
+        "bGUucHJvdG9idWYuRGVzY3JpcHRvclByb3RvLkV4dGVuc2lvblJhbmdlEjAK" + 
+        "B29wdGlvbnMYByABKAsyHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" + 
+        "bnMaLAoORXh0ZW5zaW9uUmFuZ2USDQoFc3RhcnQYASABKAUSCwoDZW5kGAIg" + 
+        "ASgFIpQFChRGaWVsZERlc2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg4K" + 
+        "Bm51bWJlchgDIAEoBRI6CgVsYWJlbBgEIAEoDjIrLmdvb2dsZS5wcm90b2J1" + 
+        "Zi5GaWVsZERlc2NyaXB0b3JQcm90by5MYWJlbBI4CgR0eXBlGAUgASgOMiou" + 
+        "Z29vZ2xlLnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvLlR5cGUSEQoJ" + 
+        "dHlwZV9uYW1lGAYgASgJEhAKCGV4dGVuZGVlGAIgASgJEhUKDWRlZmF1bHRf" + 
+        "dmFsdWUYByABKAkSLgoHb3B0aW9ucxgIIAEoCzIdLmdvb2dsZS5wcm90b2J1" + 
+        "Zi5GaWVsZE9wdGlvbnMitgIKBFR5cGUSDwoLVFlQRV9ET1VCTEUQARIOCgpU" + 
+        "WVBFX0ZMT0FUEAISDgoKVFlQRV9JTlQ2NBADEg8KC1RZUEVfVUlOVDY0EAQS" + 
+        "DgoKVFlQRV9JTlQzMhAFEhAKDFRZUEVfRklYRUQ2NBAGEhAKDFRZUEVfRklY" + 
+        "RUQzMhAHEg0KCVRZUEVfQk9PTBAIEg8KC1RZUEVfU1RSSU5HEAkSDgoKVFlQ" + 
+        "RV9HUk9VUBAKEhAKDFRZUEVfTUVTU0FHRRALEg4KClRZUEVfQllURVMQDBIP" + 
+        "CgtUWVBFX1VJTlQzMhANEg0KCVRZUEVfRU5VTRAOEhEKDVRZUEVfU0ZJWEVE" + 
+        "MzIQDxIRCg1UWVBFX1NGSVhFRDY0EBASDwoLVFlQRV9TSU5UMzIQERIPCgtU" + 
+        "WVBFX1NJTlQ2NBASIkMKBUxhYmVsEhIKDkxBQkVMX09QVElPTkFMEAESEgoO" + 
+        "TEFCRUxfUkVRVUlSRUQQAhISCg5MQUJFTF9SRVBFQVRFRBADIowBChNFbnVt" + 
+        "RGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSOAoFdmFsdWUYAiADKAsy" + 
+        "KS5nb29nbGUucHJvdG9idWYuRW51bVZhbHVlRGVzY3JpcHRvclByb3RvEi0K" + 
+        "B29wdGlvbnMYAyABKAsyHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMi" + 
+        "bAoYRW51bVZhbHVlRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSDgoG" + 
+        "bnVtYmVyGAIgASgFEjIKB29wdGlvbnMYAyABKAsyIS5nb29nbGUucHJvdG9i" + 
+        "dWYuRW51bVZhbHVlT3B0aW9ucyKQAQoWU2VydmljZURlc2NyaXB0b3JQcm90" + 
+        "bxIMCgRuYW1lGAEgASgJEjYKBm1ldGhvZBgCIAMoCzImLmdvb2dsZS5wcm90" + 
+        "b2J1Zi5NZXRob2REZXNjcmlwdG9yUHJvdG8SMAoHb3B0aW9ucxgDIAEoCzIf" + 
+        "Lmdvb2dsZS5wcm90b2J1Zi5TZXJ2aWNlT3B0aW9ucyJ/ChVNZXRob2REZXNj" + 
+        "cmlwdG9yUHJvdG8SDAoEbmFtZRgBIAEoCRISCgppbnB1dF90eXBlGAIgASgJ" + 
+        "EhMKC291dHB1dF90eXBlGAMgASgJEi8KB29wdGlvbnMYBCABKAsyHi5nb29n" + 
+        "bGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucyKrAgoLRmlsZU9wdGlvbnMSFAoM" + 
+        "amF2YV9wYWNrYWdlGAEgASgJEhwKFGphdmFfb3V0ZXJfY2xhc3NuYW1lGAgg" + 
+        "ASgJEiIKE2phdmFfbXVsdGlwbGVfZmlsZXMYCiABKAg6BWZhbHNlEkoKDG9w" + 
+        "dGltaXplX2ZvchgJIAEoDjIpLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9u" + 
+        "cy5PcHRpbWl6ZU1vZGU6CUNPREVfU0laRRJDChR1bmludGVycHJldGVkX29w" + 
+        "dGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9w" + 
+        "dGlvbiIoCgxPcHRpbWl6ZU1vZGUSCQoFU1BFRUQQARINCglDT0RFX1NJWkUQ" + 
+        "AioJCOgHEICAgIACIogBCg5NZXNzYWdlT3B0aW9ucxImChdtZXNzYWdlX3Nl" + 
+        "dF93aXJlX2Zvcm1hdBgBIAEoCDoFZmFsc2USQwoUdW5pbnRlcnByZXRlZF9v" + 
+        "cHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRP" + 
+        "cHRpb24qCQjoBxCAgICAAiLVAQoMRmllbGRPcHRpb25zEjIKBWN0eXBlGAEg" + 
+        "ASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZRIcChRl" + 
+        "eHBlcmltZW50YWxfbWFwX2tleRgJIAEoCRJDChR1bmludGVycHJldGVkX29w" + 
+        "dGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9w" + 
+        "dGlvbiIjCgVDVHlwZRIICgRDT1JEEAESEAoMU1RSSU5HX1BJRUNFEAIqCQjo" + 
+        "BxCAgICAAiJdCgtFbnVtT3B0aW9ucxJDChR1bmludGVycHJldGVkX29wdGlv" + 
+        "bhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9wdGlv" + 
+        "bioJCOgHEICAgIACImIKEEVudW1WYWx1ZU9wdGlvbnMSQwoUdW5pbnRlcnBy" + 
+        "ZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJw" + 
+        "cmV0ZWRPcHRpb24qCQjoBxCAgICAAiJgCg5TZXJ2aWNlT3B0aW9ucxJDChR1" + 
+        "bmludGVycHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYu" + 
+        "VW5pbnRlcnByZXRlZE9wdGlvbioJCOgHEICAgIACIl8KDU1ldGhvZE9wdGlv" + 
+        "bnMSQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnBy" + 
+        "b3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKFAgoTVW5p" + 
+        "bnRlcnByZXRlZE9wdGlvbhI7CgRuYW1lGAIgAygLMi0uZ29vZ2xlLnByb3Rv" + 
+        "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24uTmFtZVBhcnQSGAoQaWRlbnRpZmll" + 
+        "cl92YWx1ZRgDIAEoCRIaChJwb3NpdGl2ZV9pbnRfdmFsdWUYBCABKAQSGgoS" + 
+        "bmVnYXRpdmVfaW50X3ZhbHVlGAUgASgDEhQKDGRvdWJsZV92YWx1ZRgGIAEo" + 
+        "ARIUCgxzdHJpbmdfdmFsdWUYByABKAwaMwoITmFtZVBhcnQSEQoJbmFtZV9w" + 
+        "YXJ0GAEgAigJEhQKDGlzX2V4dGVuc2lvbhgCIAIoCEIpChNjb20uZ29vZ2xl" + 
+        "LnByb3RvYnVmQhBEZXNjcmlwdG9yUHJvdG9zSAE="),
+        new pbd::FileDescriptor[] {
         });
     #endregion
     
-    #region Extensions
-    #endregion
-    
     #region Static variables
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorSet__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorSet__Descriptor
         = Descriptor.MessageTypes[0];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.Builder> internal__static_google_protobuf_FileDescriptorSet__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.Builder>(internal__static_google_protobuf_FileDescriptorSet__Descriptor,
             new string[] { "File", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorProto__Descriptor
         = Descriptor.MessageTypes[1];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder> internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder>(internal__static_google_protobuf_FileDescriptorProto__Descriptor,
             new string[] { "Name", "Package", "Dependency", "MessageType", "EnumType", "Service", "Extension", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto__Descriptor
         = Descriptor.MessageTypes[2];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder> internal__static_google_protobuf_DescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder>(internal__static_google_protobuf_DescriptorProto__Descriptor,
             new string[] { "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "Options", });
-    internal static readonly pbd::MessageDescriptor  internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor
         = internal__static_google_protobuf_DescriptorProto__Descriptor.NestedTypes[0];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder> internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder>(internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor,
             new string[] { "Start", "End", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldDescriptorProto__Descriptor
         = Descriptor.MessageTypes[3];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder> internal__static_google_protobuf_FieldDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder>(internal__static_google_protobuf_FieldDescriptorProto__Descriptor,
             new string[] { "Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumDescriptorProto__Descriptor
         = Descriptor.MessageTypes[4];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder> internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder>(internal__static_google_protobuf_EnumDescriptorProto__Descriptor,
             new string[] { "Name", "Value", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor
         = Descriptor.MessageTypes[5];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder> internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder>(internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor,
             new string[] { "Name", "Number", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceDescriptorProto__Descriptor
         = Descriptor.MessageTypes[6];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder> internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder>(internal__static_google_protobuf_ServiceDescriptorProto__Descriptor,
             new string[] { "Name", "Method", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodDescriptorProto__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodDescriptorProto__Descriptor
         = Descriptor.MessageTypes[7];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder> internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder>(internal__static_google_protobuf_MethodDescriptorProto__Descriptor,
             new string[] { "Name", "InputType", "OutputType", "Options", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileOptions__Descriptor 
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileOptions__Descriptor
         = Descriptor.MessageTypes[8];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder> internal__static_google_protobuf_FileOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder>(internal__static_google_protobuf_FileOptions__Descriptor,
-            new string[] { "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "OptimizeFor", "CsharpNamespace", "CsharpFileClassname", "CsharpMultipleFiles", "CsharpNestClasses", "CsharpPublicClasses", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MessageOptions__Descriptor 
+            new string[] { "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "OptimizeFor", "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MessageOptions__Descriptor
         = Descriptor.MessageTypes[9];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder> internal__static_google_protobuf_MessageOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder>(internal__static_google_protobuf_MessageOptions__Descriptor,
-            new string[] { "MessageSetWireFormat", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldOptions__Descriptor 
+            new string[] { "MessageSetWireFormat", "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldOptions__Descriptor
         = Descriptor.MessageTypes[10];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder> internal__static_google_protobuf_FieldOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder>(internal__static_google_protobuf_FieldOptions__Descriptor,
-            new string[] { "Ctype", "ExperimentalMapKey", });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumOptions__Descriptor 
+            new string[] { "Ctype", "ExperimentalMapKey", "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumOptions__Descriptor
         = Descriptor.MessageTypes[11];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder> internal__static_google_protobuf_EnumOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder>(internal__static_google_protobuf_EnumOptions__Descriptor,
-            new string[] { });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueOptions__Descriptor 
+            new string[] { "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueOptions__Descriptor
         = Descriptor.MessageTypes[12];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder> internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder>(internal__static_google_protobuf_EnumValueOptions__Descriptor,
-            new string[] { });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceOptions__Descriptor 
+            new string[] { "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceOptions__Descriptor
         = Descriptor.MessageTypes[13];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder> internal__static_google_protobuf_ServiceOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder>(internal__static_google_protobuf_ServiceOptions__Descriptor,
-            new string[] { });
-    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodOptions__Descriptor 
+            new string[] { "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodOptions__Descriptor
         = Descriptor.MessageTypes[14];
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder> internal__static_google_protobuf_MethodOptions__FieldAccessorTable
         = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder>(internal__static_google_protobuf_MethodOptions__Descriptor,
-            new string[] { });
+            new string[] { "UninterpretedOption", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_UninterpretedOption__Descriptor
+        = Descriptor.MessageTypes[15];
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder> internal__static_google_protobuf_UninterpretedOption__FieldAccessorTable
+        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder>(internal__static_google_protobuf_UninterpretedOption__Descriptor,
+            new string[] { "Name", "IdentifierValue", "PositiveIntValue", "NegativeIntValue", "DoubleValue", "StringValue", });
+    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor
+        = internal__static_google_protobuf_UninterpretedOption__Descriptor.NestedTypes[0];
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder> internal__static_google_protobuf_UninterpretedOption_NamePart__FieldAccessorTable
+        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder>(internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor,
+            new string[] { "NamePart", "IsExtension", });
     #endregion
-    
   }
-  
-  #region Enums
-  #endregion
-  
   #region Messages
   public sealed partial class FileDescriptorSet : pb::GeneratedMessage<FileDescriptorSet, FileDescriptorSet.Builder> {
     private static readonly FileDescriptorSet defaultInstance = new Builder().BuildPartial();
@@ -276,20 +211,22 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorSet__FieldAccessorTable; }
     }
     
-    // repeated .google.protobuf.FileDescriptorProto file = 1;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> file_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> FileList {
-      get { return file_; } 
+      get { return file_; }
     }
-    public int FileCount
-      { get { return file_.Count; }
+    public int FileCount {
+      get { return file_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto GetFile(int index) {
-      return file_ [index];
+      return file_[index];
     }
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in FileList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -317,62 +254,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(pb::ByteString data) {
+    public static FileDescriptorSet ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(byte[] data) {
+    public static FileDescriptorSet ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(global::System.IO.Stream input) {
+    public static FileDescriptorSet ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(pb::CodedInputStream input) {
+    public static FileDescriptorSet ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet prototype) {
+    public static Builder CreateBuilder(FileDescriptorSet prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<FileDescriptorSet, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet();
+      FileDescriptorSet result = new FileDescriptorSet();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet MessageBeingBuilt {
+      protected override FileDescriptorSet MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet();
+        result = new FileDescriptorSet();
         return this;
       }
       
@@ -381,31 +306,31 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.Descriptor; }
+        get { return FileDescriptorSet.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.DefaultInstance; }
+      public override FileDescriptorSet DefaultInstanceForType {
+        get { return FileDescriptorSet.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet BuildPartial() {
+      public override FileDescriptorSet BuildPartial() {
         result.file_.MakeReadOnly();
-        global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet returnMe = result;
+        FileDescriptorSet returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet) other);
+        if (other is FileDescriptorSet) {
+          return MergeFrom((FileDescriptorSet) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.DefaultInstance) return this;
+      public override Builder MergeFrom(FileDescriptorSet other) {
+        if (other == FileDescriptorSet.DefaultInstance) return this;
         if (other.file_.Count != 0) {
           base.AddRange(other.file_, result.file_);
         }
@@ -418,17 +343,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -445,7 +369,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // repeated .google.protobuf.FileDescriptorProto file = 1;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> FileList {
         get { return result.file_; }
       }
@@ -504,7 +427,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable; }
     }
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -514,7 +436,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // optional string package = 2;
     private bool hasPackage;
     private string package_ = "";
     public bool HasPackage {
@@ -524,10 +445,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return package_; }
     }
     
-    // repeated string dependency = 3;
     private pbc::PopsicleList<string> dependency_ = new pbc::PopsicleList<string>();
     public scg::IList<string> DependencyList {
-      get { return dependency_; } 
+      get { return pbc::Lists.AsReadOnly(dependency_); }
     }
     public int DependencyCount {
       get { return dependency_.Count; }
@@ -536,55 +456,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       return dependency_[index];
     }
     
-    // repeated .google.protobuf.DescriptorProto message_type = 4;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> messageType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList {
-      get { return messageType_; } 
+      get { return messageType_; }
     }
-    public int MessageTypeCount
-      { get { return messageType_.Count; }
+    public int MessageTypeCount {
+      get { return messageType_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetMessageType(int index) {
-      return messageType_ [index];
+      return messageType_[index];
     }
     
-    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
-      get { return enumType_; } 
+      get { return enumType_; }
     }
-    public int EnumTypeCount
-      { get { return enumType_.Count; }
+    public int EnumTypeCount {
+      get { return enumType_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
-      return enumType_ [index];
+      return enumType_[index];
     }
     
-    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> service_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList {
-      get { return service_; } 
+      get { return service_; }
     }
-    public int ServiceCount
-      { get { return service_.Count; }
+    public int ServiceCount {
+      get { return service_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto GetService(int index) {
-      return service_ [index];
+      return service_[index];
     }
     
-    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
-      get { return extension_; } 
+      get { return extension_; }
     }
-    public int ExtensionCount
-      { get { return extension_.Count; }
+    public int ExtensionCount {
+      get { return extension_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
-      return extension_ [index];
+      return extension_[index];
     }
     
-    // optional .google.protobuf.FileOptions options = 8;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance;
     public bool HasOptions {
@@ -596,6 +511,21 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
+          if (!element.IsInitialized) return false;
+        }
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -642,8 +572,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           size += pb::CodedOutputStream.ComputeStringSize(2, Package);
         }
         foreach (string element in DependencyList) {
-          size += pb::CodedOutputStream
-            .ComputeStringSize(3, element);
+          size += pb::CodedOutputStream.ComputeStringSize(3, element);
         }
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
           size += pb::CodedOutputStream.ComputeMessageSize(4, element);
@@ -666,62 +595,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::ByteString data) {
+    public static FileDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(byte[] data) {
+    public static FileDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static FileDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static FileDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto prototype) {
+    public static Builder CreateBuilder(FileDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<FileDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto();
+      FileDescriptorProto result = new FileDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto MessageBeingBuilt {
+      protected override FileDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto();
+        result = new FileDescriptorProto();
         return this;
       }
       
@@ -730,35 +647,35 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Descriptor; }
+        get { return FileDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.DefaultInstance; }
+      public override FileDescriptorProto DefaultInstanceForType {
+        get { return FileDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto BuildPartial() {
+      public override FileDescriptorProto BuildPartial() {
         result.dependency_.MakeReadOnly();
         result.messageType_.MakeReadOnly();
         result.enumType_.MakeReadOnly();
         result.service_.MakeReadOnly();
         result.extension_.MakeReadOnly();
-        global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto returnMe = result;
+        FileDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto) other);
+        if (other is FileDescriptorProto) {
+          return MergeFrom((FileDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(FileDescriptorProto other) {
+        if (other == FileDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -792,17 +709,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -858,7 +774,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -877,7 +792,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string package = 2;
       public bool HasPackage {
         get { return result.HasPackage; }
       }
@@ -896,7 +810,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated string dependency = 3;
       public scg::IList<string> DependencyList {
         get { return result.dependency_; }
       }
@@ -923,7 +836,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.DescriptorProto message_type = 4;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList {
         get { return result.messageType_; }
       }
@@ -958,7 +870,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
         get { return result.enumType_; }
       }
@@ -993,7 +904,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.ServiceDescriptorProto service = 6;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList {
         get { return result.service_; }
       }
@@ -1028,7 +938,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.FieldDescriptorProto extension = 7;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
         get { return result.extension_; }
       }
@@ -1063,9 +972,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.FileOptions options = 8;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options {
         get { return result.Options; }
@@ -1084,8 +992,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -1146,7 +1053,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable; }
         }
         
-        // optional int32 start = 1;
         private bool hasStart;
         private int start_ = 0;
         public bool HasStart {
@@ -1156,7 +1062,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           get { return start_; }
         }
         
-        // optional int32 end = 2;
         private bool hasEnd;
         private int end_ = 0;
         public bool HasEnd {
@@ -1201,62 +1106,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }
         }
         
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::ByteString data) {
+        public static ExtensionRange ParseFrom(pb::ByteString data) {
           return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::ByteString data,
-            pb::ExtensionRegistry extensionRegistry) {
-          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-                   .BuildParsed();
+        public static ExtensionRange ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(byte[] data) {
+        public static ExtensionRange ParseFrom(byte[] data) {
           return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(byte[] data,
-            pb::ExtensionRegistry extensionRegistry) {
-          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-                   .BuildParsed();
+        public static ExtensionRange ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(global::System.IO.Stream input) {
+        public static ExtensionRange ParseFrom(global::System.IO.Stream input) {
           return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(
-            global::System.IO.Stream input,
-            pb::ExtensionRegistry extensionRegistry) {
-          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-                   .BuildParsed();
+        public static ExtensionRange ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::CodedInputStream input) {
+        public static ExtensionRange ParseFrom(pb::CodedInputStream input) {
           return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
         }
-        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::CodedInputStream input,
-            pb::ExtensionRegistry extensionRegistry) {
-          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-                   .BuildParsed();
+        public static ExtensionRange ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
         }
-        
         public static Builder CreateBuilder() { return new Builder(); }
         public override Builder CreateBuilderForType() { return new Builder(); }
-        public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange prototype) {
+        public static Builder CreateBuilder(ExtensionRange prototype) {
           return (Builder) new Builder().MergeFrom(prototype);
         }
         
-        public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, Builder> {
+        public sealed partial class Builder : pb::GeneratedBuilder<ExtensionRange, Builder> {
           protected override Builder ThisBuilder {
             get { return this; }
           }
-          
-          // Construct using global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.CreateBuilder()
           public Builder() {}
           
-          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange();
+          ExtensionRange result = new ExtensionRange();
           
-          protected override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange MessageBeingBuilt {
+          protected override ExtensionRange MessageBeingBuilt {
             get { return result; }
           }
           
           public override Builder Clear() {
-            result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange();
+            result = new ExtensionRange();
             return this;
           }
           
@@ -1265,30 +1158,30 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }
           
           public override pbd::MessageDescriptor DescriptorForType {
-            get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Descriptor; }
+            get { return ExtensionRange.Descriptor; }
           }
           
-          public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange DefaultInstanceForType {
-            get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.DefaultInstance; }
+          public override ExtensionRange DefaultInstanceForType {
+            get { return ExtensionRange.DefaultInstance; }
           }
           
-          public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange BuildPartial() {
-            global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange returnMe = result;
+          public override ExtensionRange BuildPartial() {
+            ExtensionRange returnMe = result;
             result = null;
             return returnMe;
           }
           
           public override Builder MergeFrom(pb::IMessage other) {
-            if (other is global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange) {
-              return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange) other);
+            if (other is ExtensionRange) {
+              return MergeFrom((ExtensionRange) other);
             } else {
               base.MergeFrom(other);
               return this;
             }
           }
           
-          public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange other) {
-            if (other == global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.DefaultInstance) return this;
+          public override Builder MergeFrom(ExtensionRange other) {
+            if (other == ExtensionRange.DefaultInstance) return this;
             if (other.HasStart) {
               Start = other.Start;
             }
@@ -1304,17 +1197,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }
           
           public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-            pb::UnknownFieldSet.Builder unknownFields =
-              pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+            pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
             while (true) {
               uint tag = input.ReadTag();
               switch (tag) {
-                case 0:
+                case 0: {
                   this.UnknownFields = unknownFields.Build();
                   return this;
+                }
                 default: {
-                  if (!ParseUnknownField(input, unknownFields,
-                                         extensionRegistry, tag)) {
+                  if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                     this.UnknownFields = unknownFields.Build();
                     return this;
                   }
@@ -1333,7 +1225,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
           }
           
           
-          // optional int32 start = 1;
           public bool HasStart {
             get { return result.HasStart; }
           }
@@ -1352,7 +1243,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
             return this;
           }
           
-          // optional int32 end = 2;
           public bool HasEnd {
             get { return result.HasEnd; }
           }
@@ -1376,7 +1266,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     }
     #endregion
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -1386,67 +1275,61 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // repeated .google.protobuf.FieldDescriptorProto field = 2;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> field_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList {
-      get { return field_; } 
+      get { return field_; }
     }
-    public int FieldCount
-      { get { return field_.Count; }
+    public int FieldCount {
+      get { return field_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetField(int index) {
-      return field_ [index];
+      return field_[index];
     }
     
-    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
-      get { return extension_; } 
+      get { return extension_; }
     }
-    public int ExtensionCount
-      { get { return extension_.Count; }
+    public int ExtensionCount {
+      get { return extension_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
-      return extension_ [index];
+      return extension_[index];
     }
     
-    // repeated .google.protobuf.DescriptorProto nested_type = 3;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> nestedType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList {
-      get { return nestedType_; } 
+      get { return nestedType_; }
     }
-    public int NestedTypeCount
-      { get { return nestedType_.Count; }
+    public int NestedTypeCount {
+      get { return nestedType_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetNestedType(int index) {
-      return nestedType_ [index];
+      return nestedType_[index];
     }
     
-    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
-      get { return enumType_; } 
+      get { return enumType_; }
     }
-    public int EnumTypeCount
-      { get { return enumType_.Count; }
+    public int EnumTypeCount {
+      get { return enumType_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
-      return enumType_ [index];
+      return enumType_[index];
     }
     
-    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList {
-      get { return extensionRange_; } 
+      get { return extensionRange_; }
     }
-    public int ExtensionRangeCount
-      { get { return extensionRange_.Count; }
+    public int ExtensionRangeCount {
+      get { return extensionRange_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange GetExtensionRange(int index) {
-      return extensionRange_ [index];
+      return extensionRange_[index];
     }
     
-    // optional .google.protobuf.MessageOptions options = 7;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance;
     public bool HasOptions {
@@ -1458,6 +1341,21 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) {
+          if (!element.IsInitialized) return false;
+        }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
+          if (!element.IsInitialized) return false;
+        }
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -1500,6 +1398,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) {
           size += pb::CodedOutputStream.ComputeMessageSize(2, element);
         }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(6, element);
+        }
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) {
           size += pb::CodedOutputStream.ComputeMessageSize(3, element);
         }
@@ -1509,9 +1410,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) {
           size += pb::CodedOutputStream.ComputeMessageSize(5, element);
         }
-        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
-          size += pb::CodedOutputStream.ComputeMessageSize(6, element);
-        }
         if (HasOptions) {
           size += pb::CodedOutputStream.ComputeMessageSize(7, Options);
         }
@@ -1521,62 +1419,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::ByteString data) {
+    public static DescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static DescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(byte[] data) {
+    public static DescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static DescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static DescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static DescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static DescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static DescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto prototype) {
+    public static Builder CreateBuilder(DescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<DescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto();
+      DescriptorProto result = new DescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto MessageBeingBuilt {
+      protected override DescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto();
+        result = new DescriptorProto();
         return this;
       }
       
@@ -1585,35 +1471,35 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Descriptor; }
+        get { return DescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.DefaultInstance; }
+      public override DescriptorProto DefaultInstanceForType {
+        get { return DescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto BuildPartial() {
+      public override DescriptorProto BuildPartial() {
         result.field_.MakeReadOnly();
         result.extension_.MakeReadOnly();
         result.nestedType_.MakeReadOnly();
         result.enumType_.MakeReadOnly();
         result.extensionRange_.MakeReadOnly();
-        global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto returnMe = result;
+        DescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto) other);
+        if (other is DescriptorProto) {
+          return MergeFrom((DescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(DescriptorProto other) {
+        if (other == DescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -1644,17 +1530,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -1708,7 +1593,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -1727,7 +1611,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.FieldDescriptorProto field = 2;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList {
         get { return result.field_; }
       }
@@ -1762,7 +1645,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.FieldDescriptorProto extension = 6;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
         get { return result.extension_; }
       }
@@ -1797,7 +1679,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.DescriptorProto nested_type = 3;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList {
         get { return result.nestedType_; }
       }
@@ -1832,7 +1713,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
         get { return result.enumType_; }
       }
@@ -1867,7 +1747,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList {
         get { return result.extensionRange_; }
       }
@@ -1902,9 +1781,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.MessageOptions options = 7;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options {
         get { return result.Options; }
@@ -1923,8 +1801,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -1993,7 +1870,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     }
     #endregion
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -2003,7 +1879,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // optional int32 number = 3;
     private bool hasNumber;
     private int number_ = 0;
     public bool HasNumber {
@@ -2013,23 +1888,24 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return number_; }
     }
     
-    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
     private bool hasLabel;
     private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label label_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL;
     public bool HasLabel {
       get { return hasLabel; }
     }
-    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {  get { return label_; }}
+    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {
+      get { return label_; }
+    }
     
-    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
     private bool hasType;
     private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type type_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type.TYPE_DOUBLE;
     public bool HasType {
       get { return hasType; }
     }
-    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {  get { return type_; }}
+    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {
+      get { return type_; }
+    }
     
-    // optional string type_name = 6;
     private bool hasTypeName;
     private string typeName_ = "";
     public bool HasTypeName {
@@ -2039,7 +1915,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return typeName_; }
     }
     
-    // optional string extendee = 2;
     private bool hasExtendee;
     private string extendee_ = "";
     public bool HasExtendee {
@@ -2049,7 +1924,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return extendee_; }
     }
     
-    // optional string default_value = 7;
     private bool hasDefaultValue;
     private string defaultValue_ = "";
     public bool HasDefaultValue {
@@ -2059,7 +1933,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return defaultValue_; }
     }
     
-    // optional .google.protobuf.FieldOptions options = 8;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance;
     public bool HasOptions {
@@ -2071,6 +1944,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -2113,23 +1989,21 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         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);
+          size += pb::CodedOutputStream.ComputeEnumSize(4, (int) Label);
         }
         if (HasType) {
-          size += pb::CodedOutputStream
-            .ComputeEnumSize(5, (int) Type);
+          size += pb::CodedOutputStream.ComputeEnumSize(5, (int) Type);
         }
         if (HasTypeName) {
           size += pb::CodedOutputStream.ComputeStringSize(6, TypeName);
         }
+        if (HasExtendee) {
+          size += pb::CodedOutputStream.ComputeStringSize(2, Extendee);
+        }
         if (HasDefaultValue) {
           size += pb::CodedOutputStream.ComputeStringSize(7, DefaultValue);
         }
@@ -2142,62 +2016,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::ByteString data) {
+    public static FieldDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FieldDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(byte[] data) {
+    public static FieldDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FieldDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static FieldDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FieldDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static FieldDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FieldDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto prototype) {
+    public static Builder CreateBuilder(FieldDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<FieldDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto();
+      FieldDescriptorProto result = new FieldDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto MessageBeingBuilt {
+      protected override FieldDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto();
+        result = new FieldDescriptorProto();
         return this;
       }
       
@@ -2206,30 +2068,30 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Descriptor; }
+        get { return FieldDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.DefaultInstance; }
+      public override FieldDescriptorProto DefaultInstanceForType {
+        get { return FieldDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto returnMe = result;
+      public override FieldDescriptorProto BuildPartial() {
+        FieldDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto) other);
+        if (other is FieldDescriptorProto) {
+          return MergeFrom((FieldDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(FieldDescriptorProto other) {
+        if (other == FieldDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -2263,17 +2125,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -2331,7 +2192,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -2350,7 +2210,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional int32 number = 3;
       public bool HasNumber {
         get { return result.HasNumber; }
       }
@@ -2369,9 +2228,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
       public bool HasLabel {
-        get { return result.HasLabel; }
+       get { return result.HasLabel; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {
         get { return result.Label; }
@@ -2388,9 +2246,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
       public bool HasType {
-        get { return result.HasType; }
+       get { return result.HasType; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {
         get { return result.Type; }
@@ -2407,7 +2264,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string type_name = 6;
       public bool HasTypeName {
         get { return result.HasTypeName; }
       }
@@ -2426,7 +2282,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string extendee = 2;
       public bool HasExtendee {
         get { return result.HasExtendee; }
       }
@@ -2445,7 +2300,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string default_value = 7;
       public bool HasDefaultValue {
         get { return result.HasDefaultValue; }
       }
@@ -2464,9 +2318,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.FieldOptions options = 8;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options {
         get { return result.Options; }
@@ -2485,8 +2338,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -2523,7 +2375,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable; }
     }
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -2533,19 +2384,17 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> value_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList {
-      get { return value_; } 
+      get { return value_; }
     }
-    public int ValueCount
-      { get { return value_.Count; }
+    public int ValueCount {
+      get { return value_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto GetValue(int index) {
-      return value_ [index];
+      return value_[index];
     }
     
-    // optional .google.protobuf.EnumOptions options = 3;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance;
     public bool HasOptions {
@@ -2557,6 +2406,12 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) {
+          if (!element.IsInitialized) return false;
+        }
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -2596,62 +2451,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::ByteString data) {
+    public static EnumDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(byte[] data) {
+    public static EnumDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static EnumDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static EnumDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto prototype) {
+    public static Builder CreateBuilder(EnumDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<EnumDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto();
+      EnumDescriptorProto result = new EnumDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto MessageBeingBuilt {
+      protected override EnumDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto();
+        result = new EnumDescriptorProto();
         return this;
       }
       
@@ -2660,31 +2503,31 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Descriptor; }
+        get { return EnumDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.DefaultInstance; }
+      public override EnumDescriptorProto DefaultInstanceForType {
+        get { return EnumDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto BuildPartial() {
+      public override EnumDescriptorProto BuildPartial() {
         result.value_.MakeReadOnly();
-        global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto returnMe = result;
+        EnumDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto) other);
+        if (other is EnumDescriptorProto) {
+          return MergeFrom((EnumDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(EnumDescriptorProto other) {
+        if (other == EnumDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -2703,17 +2546,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -2743,7 +2585,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -2762,7 +2603,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList {
         get { return result.value_; }
       }
@@ -2797,9 +2637,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.EnumOptions options = 3;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options {
         get { return result.Options; }
@@ -2818,8 +2657,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -2856,7 +2694,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable; }
     }
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -2866,7 +2703,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // optional int32 number = 2;
     private bool hasNumber;
     private int number_ = 0;
     public bool HasNumber {
@@ -2876,7 +2712,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return number_; }
     }
     
-    // optional .google.protobuf.EnumValueOptions options = 3;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance;
     public bool HasOptions {
@@ -2888,6 +2723,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -2927,62 +2765,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::ByteString data) {
+    public static EnumValueDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(byte[] data) {
+    public static EnumValueDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto prototype) {
+    public static Builder CreateBuilder(EnumValueDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<EnumValueDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto();
+      EnumValueDescriptorProto result = new EnumValueDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto MessageBeingBuilt {
+      protected override EnumValueDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto();
+        result = new EnumValueDescriptorProto();
         return this;
       }
       
@@ -2991,30 +2817,30 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Descriptor; }
+        get { return EnumValueDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.DefaultInstance; }
+      public override EnumValueDescriptorProto DefaultInstanceForType {
+        get { return EnumValueDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto returnMe = result;
+      public override EnumValueDescriptorProto BuildPartial() {
+        EnumValueDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto) other);
+        if (other is EnumValueDescriptorProto) {
+          return MergeFrom((EnumValueDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(EnumValueDescriptorProto other) {
+        if (other == EnumValueDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -3033,17 +2859,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -3071,7 +2896,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -3090,7 +2914,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional int32 number = 2;
       public bool HasNumber {
         get { return result.HasNumber; }
       }
@@ -3109,9 +2932,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.EnumValueOptions options = 3;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options {
         get { return result.Options; }
@@ -3130,8 +2952,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -3168,7 +2989,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable; }
     }
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -3178,19 +2998,17 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // repeated .google.protobuf.MethodDescriptorProto method = 2;
     private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> method_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>();
     public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList {
-      get { return method_; } 
+      get { return method_; }
     }
-    public int MethodCount
-      { get { return method_.Count; }
+    public int MethodCount {
+      get { return method_.Count; }
     }
     public global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto GetMethod(int index) {
-      return method_ [index];
+      return method_[index];
     }
     
-    // optional .google.protobuf.ServiceOptions options = 3;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance;
     public bool HasOptions {
@@ -3202,6 +3020,12 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) {
+          if (!element.IsInitialized) return false;
+        }
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -3241,62 +3065,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::ByteString data) {
+    public static ServiceDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ServiceDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(byte[] data) {
+    public static ServiceDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ServiceDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static ServiceDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ServiceDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static ServiceDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ServiceDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto prototype) {
+    public static Builder CreateBuilder(ServiceDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<ServiceDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto();
+      ServiceDescriptorProto result = new ServiceDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto MessageBeingBuilt {
+      protected override ServiceDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto();
+        result = new ServiceDescriptorProto();
         return this;
       }
       
@@ -3305,31 +3117,31 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Descriptor; }
+        get { return ServiceDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.DefaultInstance; }
+      public override ServiceDescriptorProto DefaultInstanceForType {
+        get { return ServiceDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto BuildPartial() {
+      public override ServiceDescriptorProto BuildPartial() {
         result.method_.MakeReadOnly();
-        global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto returnMe = result;
+        ServiceDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto) other);
+        if (other is ServiceDescriptorProto) {
+          return MergeFrom((ServiceDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(ServiceDescriptorProto other) {
+        if (other == ServiceDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -3348,17 +3160,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -3388,7 +3199,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -3407,7 +3217,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // repeated .google.protobuf.MethodDescriptorProto method = 2;
       public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList {
         get { return result.method_; }
       }
@@ -3442,9 +3251,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.ServiceOptions options = 3;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options {
         get { return result.Options; }
@@ -3463,8 +3271,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -3501,7 +3308,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable; }
     }
     
-    // optional string name = 1;
     private bool hasName;
     private string name_ = "";
     public bool HasName {
@@ -3511,7 +3317,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return name_; }
     }
     
-    // optional string input_type = 2;
     private bool hasInputType;
     private string inputType_ = "";
     public bool HasInputType {
@@ -3521,7 +3326,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return inputType_; }
     }
     
-    // optional string output_type = 3;
     private bool hasOutputType;
     private string outputType_ = "";
     public bool HasOutputType {
@@ -3531,7 +3335,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return outputType_; }
     }
     
-    // optional .google.protobuf.MethodOptions options = 4;
     private bool hasOptions;
     private global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance;
     public bool HasOptions {
@@ -3543,6 +3346,9 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     
     public override bool IsInitialized {
       get {
+        if (HasOptions) {
+          if (!Options.IsInitialized) return false;
+        }
         return true;
       }
     }
@@ -3588,62 +3394,50 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::ByteString data) {
+    public static MethodDescriptorProto ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MethodDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(byte[] data) {
+    public static MethodDescriptorProto ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MethodDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(global::System.IO.Stream input) {
+    public static MethodDescriptorProto ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MethodDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::CodedInputStream input) {
+    public static MethodDescriptorProto ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MethodDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto prototype) {
+    public static Builder CreateBuilder(MethodDescriptorProto prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, Builder> {
+    public sealed partial class Builder : pb::GeneratedBuilder<MethodDescriptorProto, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto();
+      MethodDescriptorProto result = new MethodDescriptorProto();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto MessageBeingBuilt {
+      protected override MethodDescriptorProto MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto();
+        result = new MethodDescriptorProto();
         return this;
       }
       
@@ -3652,30 +3446,30 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Descriptor; }
+        get { return MethodDescriptorProto.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.DefaultInstance; }
+      public override MethodDescriptorProto DefaultInstanceForType {
+        get { return MethodDescriptorProto.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto returnMe = result;
+      public override MethodDescriptorProto BuildPartial() {
+        MethodDescriptorProto returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto) other);
+        if (other is MethodDescriptorProto) {
+          return MergeFrom((MethodDescriptorProto) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.DefaultInstance) return this;
+      public override Builder MergeFrom(MethodDescriptorProto other) {
+        if (other == MethodDescriptorProto.DefaultInstance) return this;
         if (other.HasName) {
           Name = other.Name;
         }
@@ -3697,17 +3491,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -3739,7 +3532,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string name = 1;
       public bool HasName {
         get { return result.HasName; }
       }
@@ -3758,7 +3550,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string input_type = 2;
       public bool HasInputType {
         get { return result.HasInputType; }
       }
@@ -3777,7 +3568,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string output_type = 3;
       public bool HasOutputType {
         get { return result.HasOutputType; }
       }
@@ -3796,9 +3586,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.MethodOptions options = 4;
       public bool HasOptions {
-        get { return result.HasOptions; }
+       get { return result.HasOptions; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options {
         get { return result.Options; }
@@ -3817,8 +3606,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) {
         if (result.HasOptions &&
             result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) {
-          result.options_ =
-            global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
+            result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
         } else {
           result.options_ = value;
         }
@@ -3833,7 +3621,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     }
   }
   
-  public sealed partial class FileOptions : pb::GeneratedMessage<FileOptions, FileOptions.Builder> {
+  public sealed partial class FileOptions : pb::ExtendableMessage<FileOptions, FileOptions.Builder> {
     private static readonly FileOptions defaultInstance = new Builder().BuildPartial();
     public static FileOptions DefaultInstance {
       get { return defaultInstance; }
@@ -3865,7 +3653,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     }
     #endregion
     
-    // optional string java_package = 1;
     private bool hasJavaPackage;
     private string javaPackage_ = "";
     public bool HasJavaPackage {
@@ -3875,7 +3662,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return javaPackage_; }
     }
     
-    // optional string java_outer_classname = 8;
     private bool hasJavaOuterClassname;
     private string javaOuterClassname_ = "";
     public bool HasJavaOuterClassname {
@@ -3885,7 +3671,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return javaOuterClassname_; }
     }
     
-    // optional bool java_multiple_files = 10 [default = false];
     private bool hasJavaMultipleFiles;
     private bool javaMultipleFiles_ = false;
     public bool HasJavaMultipleFiles {
@@ -3895,71 +3680,37 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return javaMultipleFiles_; }
     }
     
-    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
     private bool hasOptimizeFor;
     private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode optimizeFor_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode.CODE_SIZE;
     public bool HasOptimizeFor {
       get { return hasOptimizeFor; }
     }
-    public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {  get { return optimizeFor_; }}
-    
-    // optional string csharp_namespace = 1000;
-    private bool hasCsharpNamespace;
-    private string csharpNamespace_ = "";
-    public bool HasCsharpNamespace {
-      get { return hasCsharpNamespace; }
-    }
-    public string CsharpNamespace {
-      get { return csharpNamespace_; }
-    }
-    
-    // optional string csharp_file_classname = 1001;
-    private bool hasCsharpFileClassname;
-    private string csharpFileClassname_ = "";
-    public bool HasCsharpFileClassname {
-      get { return hasCsharpFileClassname; }
-    }
-    public string CsharpFileClassname {
-      get { return csharpFileClassname_; }
-    }
-    
-    // optional bool csharp_multiple_files = 1002 [default = false];
-    private bool hasCsharpMultipleFiles;
-    private bool csharpMultipleFiles_ = false;
-    public bool HasCsharpMultipleFiles {
-      get { return hasCsharpMultipleFiles; }
-    }
-    public bool CsharpMultipleFiles {
-      get { return csharpMultipleFiles_; }
+    public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {
+      get { return optimizeFor_; }
     }
     
-    // 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_; }
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
     }
-    
-    // optional bool csharp_public_classes = 1004 [default = true];
-    private bool hasCsharpPublicClasses;
-    private bool csharpPublicClasses_ = true;
-    public bool HasCsharpPublicClasses {
-      get { return hasCsharpPublicClasses; }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
     }
-    public bool CsharpPublicClasses {
-      get { return csharpPublicClasses_; }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
     }
     
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<FileOptions, FileOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
       if (HasJavaPackage) {
         output.WriteString(1, JavaPackage);
       }
@@ -3972,21 +3723,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       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);
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
       }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -4003,90 +3743,66 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         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 (HasOptimizeFor) {
+          size += pb::CodedOutputStream.ComputeEnumSize(9, (int) OptimizeFor);
         }
-        if (HasCsharpPublicClasses) {
-          size += pb::CodedOutputStream.ComputeBoolSize(1004, CsharpPublicClasses);
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
         }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::ByteString data) {
+    public static FileOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(byte[] data) {
+    public static FileOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(global::System.IO.Stream input) {
+    public static FileOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::CodedInputStream input) {
+    public static FileOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FileOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions prototype) {
+    public static Builder CreateBuilder(FileOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<FileOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.FileOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.FileOptions();
+      FileOptions result = new FileOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions MessageBeingBuilt {
+      protected override FileOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.FileOptions();
+        result = new FileOptions();
         return this;
       }
       
@@ -4095,30 +3811,31 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Descriptor; }
+        get { return FileOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance; }
+      public override FileOptions DefaultInstanceForType {
+        get { return FileOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.FileOptions returnMe = result;
+      public override FileOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        FileOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FileOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FileOptions) other);
+        if (other is FileOptions) {
+          return MergeFrom((FileOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(FileOptions other) {
+        if (other == FileOptions.DefaultInstance) return this;
         if (other.HasJavaPackage) {
           JavaPackage = other.JavaPackage;
         }
@@ -4131,20 +3848,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         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;
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
         }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
@@ -4155,17 +3860,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -4192,24 +3896,10 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
               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();
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
               break;
             }
           }
@@ -4217,7 +3907,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       
-      // optional string java_package = 1;
       public bool HasJavaPackage {
         get { return result.HasJavaPackage; }
       }
@@ -4236,7 +3925,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string java_outer_classname = 8;
       public bool HasJavaOuterClassname {
         get { return result.HasJavaOuterClassname; }
       }
@@ -4255,7 +3943,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional bool java_multiple_files = 10 [default = false];
       public bool HasJavaMultipleFiles {
         get { return result.HasJavaMultipleFiles; }
       }
@@ -4274,9 +3961,8 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
       public bool HasOptimizeFor {
-        get { return result.HasOptimizeFor; }
+       get { return result.HasOptimizeFor; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {
         get { return result.OptimizeFor; }
@@ -4293,104 +3979,43 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string csharp_namespace = 1000;
-      public bool HasCsharpNamespace {
-        get { return result.HasCsharpNamespace; }
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
       }
-      public string CsharpNamespace {
-        get { return result.CsharpNamespace; }
-        set { SetCsharpNamespace(value); }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
       }
-      public Builder SetCsharpNamespace(string value) {
-        result.hasCsharpNamespace = true;
-        result.csharpNamespace_ = value;
-        return this;
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
       }
-      public Builder ClearCsharpNamespace() {
-        result.hasCsharpNamespace = false;
-        result.csharpNamespace_ = "";
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
         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;
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
         return this;
       }
-      public Builder ClearCsharpFileClassname() {
-        result.hasCsharpFileClassname = false;
-        result.csharpFileClassname_ = "";
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
         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;
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
         return this;
       }
-      public Builder ClearCsharpMultipleFiles() {
-        result.hasCsharpMultipleFiles = false;
-        result.csharpMultipleFiles_ = false;
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
         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;
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
         return this;
       }
     }
   }
   
-  public sealed partial class MessageOptions : pb::GeneratedMessage<MessageOptions, MessageOptions.Builder> {
+  public sealed partial class MessageOptions : pb::ExtendableMessage<MessageOptions, MessageOptions.Builder> {
     private static readonly MessageOptions defaultInstance = new Builder().BuildPartial();
     public static MessageOptions DefaultInstance {
       get { return defaultInstance; }
@@ -4412,7 +4037,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MessageOptions__FieldAccessorTable; }
     }
     
-    // optional bool message_set_wire_format = 1 [default = false];
     private bool hasMessageSetWireFormat;
     private bool messageSetWireFormat_ = false;
     public bool HasMessageSetWireFormat {
@@ -4422,16 +4046,35 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return messageSetWireFormat_; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<MessageOptions, MessageOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
       if (HasMessageSetWireFormat) {
         output.WriteBool(1, MessageSetWireFormat);
       }
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -4445,68 +4088,60 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (HasMessageSetWireFormat) {
           size += pb::CodedOutputStream.ComputeBoolSize(1, MessageSetWireFormat);
         }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::ByteString data) {
+    public static MessageOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MessageOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(byte[] data) {
+    public static MessageOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MessageOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(global::System.IO.Stream input) {
+    public static MessageOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MessageOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::CodedInputStream input) {
+    public static MessageOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MessageOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions prototype) {
+    public static Builder CreateBuilder(MessageOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<MessageOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions();
+      MessageOptions result = new MessageOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions MessageBeingBuilt {
+      protected override MessageOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions();
+        result = new MessageOptions();
         return this;
       }
       
@@ -4515,33 +4150,37 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Descriptor; }
+        get { return MessageOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance; }
+      public override MessageOptions DefaultInstanceForType {
+        get { return MessageOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions returnMe = result;
+      public override MessageOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        MessageOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions) other);
+        if (other is MessageOptions) {
+          return MergeFrom((MessageOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(MessageOptions other) {
+        if (other == MessageOptions.DefaultInstance) return this;
         if (other.HasMessageSetWireFormat) {
           MessageSetWireFormat = other.MessageSetWireFormat;
         }
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -4551,17 +4190,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -4571,12 +4209,17 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
               MessageSetWireFormat = input.ReadBool();
               break;
             }
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
           }
         }
       }
       
       
-      // optional bool message_set_wire_format = 1 [default = false];
       public bool HasMessageSetWireFormat {
         get { return result.HasMessageSetWireFormat; }
       }
@@ -4594,10 +4237,44 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         result.messageSetWireFormat_ = false;
         return this;
       }
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
     }
   }
   
-  public sealed partial class FieldOptions : pb::GeneratedMessage<FieldOptions, FieldOptions.Builder> {
+  public sealed partial class FieldOptions : pb::ExtendableMessage<FieldOptions, FieldOptions.Builder> {
     private static readonly FieldOptions defaultInstance = new Builder().BuildPartial();
     public static FieldOptions DefaultInstance {
       get { return defaultInstance; }
@@ -4629,15 +4306,15 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
     }
     #endregion
     
-    // optional .google.protobuf.FieldOptions.CType ctype = 1;
     private bool hasCtype;
     private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType ctype_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType.CORD;
     public bool HasCtype {
       get { return hasCtype; }
     }
-    public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {  get { return ctype_; }}
+    public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {
+      get { return ctype_; }
+    }
     
-    // optional string experimental_map_key = 9;
     private bool hasExperimentalMapKey;
     private string experimentalMapKey_ = "";
     public bool HasExperimentalMapKey {
@@ -4647,19 +4324,38 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return experimentalMapKey_; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<FieldOptions, FieldOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
       if (HasCtype) {
         output.WriteEnum(1, (int) Ctype);
       }
       if (HasExperimentalMapKey) {
         output.WriteString(9, ExperimentalMapKey);
       }
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -4671,74 +4367,65 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         
         size = 0;
         if (HasCtype) {
-          size += pb::CodedOutputStream
-            .ComputeEnumSize(1, (int) Ctype);
+          size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Ctype);
         }
         if (HasExperimentalMapKey) {
           size += pb::CodedOutputStream.ComputeStringSize(9, ExperimentalMapKey);
         }
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::ByteString data) {
+    public static FieldOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(byte[] data) {
+    public static FieldOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static FieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(global::System.IO.Stream input) {
+    public static FieldOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::CodedInputStream input) {
+    public static FieldOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static FieldOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions prototype) {
+    public static Builder CreateBuilder(FieldOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<FieldOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions();
+      FieldOptions result = new FieldOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions MessageBeingBuilt {
+      protected override FieldOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions();
+        result = new FieldOptions();
         return this;
       }
       
@@ -4747,36 +4434,40 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Descriptor; }
+        get { return FieldOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance; }
+      public override FieldOptions DefaultInstanceForType {
+        get { return FieldOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions returnMe = result;
+      public override FieldOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        FieldOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions) other);
+        if (other is FieldOptions) {
+          return MergeFrom((FieldOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(FieldOptions other) {
+        if (other == FieldOptions.DefaultInstance) return this;
         if (other.HasCtype) {
           Ctype = other.Ctype;
         }
         if (other.HasExperimentalMapKey) {
           ExperimentalMapKey = other.ExperimentalMapKey;
         }
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -4786,17 +4477,16 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
@@ -4815,14 +4505,19 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
               ExperimentalMapKey = input.ReadString();
               break;
             }
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
           }
         }
       }
       
       
-      // optional .google.protobuf.FieldOptions.CType ctype = 1;
       public bool HasCtype {
-        get { return result.HasCtype; }
+       get { return result.HasCtype; }
       }
       public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {
         get { return result.Ctype; }
@@ -4839,7 +4534,6 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         return this;
       }
       
-      // optional string experimental_map_key = 9;
       public bool HasExperimentalMapKey {
         get { return result.HasExperimentalMapKey; }
       }
@@ -4857,10 +4551,44 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         result.experimentalMapKey_ = "";
         return this;
       }
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
     }
   }
   
-  public sealed partial class EnumOptions : pb::GeneratedMessage<EnumOptions, EnumOptions.Builder> {
+  public sealed partial class EnumOptions : pb::ExtendableMessage<EnumOptions, EnumOptions.Builder> {
     private static readonly EnumOptions defaultInstance = new Builder().BuildPartial();
     public static EnumOptions DefaultInstance {
       get { return defaultInstance; }
@@ -4882,13 +4610,32 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumOptions__FieldAccessorTable; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<EnumOptions, EnumOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -4899,68 +4646,60 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;
         
         size = 0;
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::ByteString data) {
+    public static EnumOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(byte[] data) {
+    public static EnumOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(global::System.IO.Stream input) {
+    public static EnumOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::CodedInputStream input) {
+    public static EnumOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions prototype) {
+    public static Builder CreateBuilder(EnumOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<EnumOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions();
+      EnumOptions result = new EnumOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions MessageBeingBuilt {
+      protected override EnumOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions();
+        result = new EnumOptions();
         return this;
       }
       
@@ -4969,30 +4708,34 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Descriptor; }
+        get { return EnumOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance; }
+      public override EnumOptions DefaultInstanceForType {
+        get { return EnumOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions returnMe = result;
+      public override EnumOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        EnumOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions) other);
+        if (other is EnumOptions) {
+          return MergeFrom((EnumOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(EnumOptions other) {
+        if (other == EnumOptions.DefaultInstance) return this;
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -5002,30 +4745,69 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
               break;
             }
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
           }
         }
       }
       
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
     }
   }
   
-  public sealed partial class EnumValueOptions : pb::GeneratedMessage<EnumValueOptions, EnumValueOptions.Builder> {
+  public sealed partial class EnumValueOptions : pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder> {
     private static readonly EnumValueOptions defaultInstance = new Builder().BuildPartial();
     public static EnumValueOptions DefaultInstance {
       get { return defaultInstance; }
@@ -5047,13 +4829,32 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -5064,68 +4865,60 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;
         
         size = 0;
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::ByteString data) {
+    public static EnumValueOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(byte[] data) {
+    public static EnumValueOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(global::System.IO.Stream input) {
+    public static EnumValueOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::CodedInputStream input) {
+    public static EnumValueOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static EnumValueOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions prototype) {
+    public static Builder CreateBuilder(EnumValueOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<EnumValueOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions();
+      EnumValueOptions result = new EnumValueOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions MessageBeingBuilt {
+      protected override EnumValueOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions();
+        result = new EnumValueOptions();
         return this;
       }
       
@@ -5134,30 +4927,34 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Descriptor; }
+        get { return EnumValueOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance; }
+      public override EnumValueOptions DefaultInstanceForType {
+        get { return EnumValueOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions returnMe = result;
+      public override EnumValueOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        EnumValueOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions) other);
+        if (other is EnumValueOptions) {
+          return MergeFrom((EnumValueOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(EnumValueOptions other) {
+        if (other == EnumValueOptions.DefaultInstance) return this;
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -5167,30 +4964,69 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
               break;
             }
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
           }
         }
       }
       
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
     }
   }
   
-  public sealed partial class ServiceOptions : pb::GeneratedMessage<ServiceOptions, ServiceOptions.Builder> {
+  public sealed partial class ServiceOptions : pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder> {
     private static readonly ServiceOptions defaultInstance = new Builder().BuildPartial();
     public static ServiceOptions DefaultInstance {
       get { return defaultInstance; }
@@ -5212,13 +5048,32 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceOptions__FieldAccessorTable; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -5229,68 +5084,60 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;
         
         size = 0;
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::ByteString data) {
+    public static ServiceOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ServiceOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(byte[] data) {
+    public static ServiceOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static ServiceOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(global::System.IO.Stream input) {
+    public static ServiceOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ServiceOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::CodedInputStream input) {
+    public static ServiceOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static ServiceOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions prototype) {
+    public static Builder CreateBuilder(ServiceOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<ServiceOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
-      
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder()
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions();
+      ServiceOptions result = new ServiceOptions();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions MessageBeingBuilt {
+      protected override ServiceOptions MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions();
+        result = new ServiceOptions();
         return this;
       }
       
@@ -5299,30 +5146,34 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Descriptor; }
+        get { return ServiceOptions.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance; }
+      public override ServiceOptions DefaultInstanceForType {
+        get { return ServiceOptions.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions returnMe = result;
+      public override ServiceOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        ServiceOptions returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions) other);
+        if (other is ServiceOptions) {
+          return MergeFrom((ServiceOptions) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(ServiceOptions other) {
+        if (other == ServiceOptions.DefaultInstance) return this;
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -5332,30 +5183,69 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
               break;
             }
+            case 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
           }
         }
       }
       
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
     }
   }
   
-  public sealed partial class MethodOptions : pb::GeneratedMessage<MethodOptions, MethodOptions.Builder> {
+  public sealed partial class MethodOptions : pb::ExtendableMessage<MethodOptions, MethodOptions.Builder> {
     private static readonly MethodOptions defaultInstance = new Builder().BuildPartial();
     public static MethodOptions DefaultInstance {
       get { return defaultInstance; }
@@ -5377,13 +5267,32 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodOptions__FieldAccessorTable; }
     }
     
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+      get { return uninterpretedOption_; }
+    }
+    public int UninterpretedOptionCount {
+      get { return uninterpretedOption_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+      return uninterpretedOption_[index];
+    }
+    
     public override bool IsInitialized {
       get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          if (!element.IsInitialized) return false;
+        }
         return true;
       }
     }
     
     public override void WriteTo(pb::CodedOutputStream output) {
+      pb::ExtendableMessage<MethodOptions, MethodOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+        output.WriteMessage(999, element);
+      }
+      extensionWriter.WriteUntil(536870912, output);
       UnknownFields.WriteTo(output);
     }
     
@@ -5394,68 +5303,590 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
         if (size != -1) return size;
         
         size = 0;
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(999, element);
+        }
+        size += ExtensionsSerializedSize;
         size += UnknownFields.SerializedSize;
         memoizedSerializedSize = size;
         return size;
       }
     }
     
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::ByteString data) {
+    public static MethodOptions ParseFrom(pb::ByteString data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::ByteString data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MethodOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(byte[] data) {
+    public static MethodOptions ParseFrom(byte[] data) {
       return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(byte[] data,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
-               .BuildParsed();
+    public static MethodOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(global::System.IO.Stream input) {
+    public static MethodOptions ParseFrom(global::System.IO.Stream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(
-        global::System.IO.Stream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MethodOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::CodedInputStream input) {
+    public static MethodOptions ParseFrom(pb::CodedInputStream input) {
       return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
     }
-    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::CodedInputStream input,
-        pb::ExtensionRegistry extensionRegistry) {
-      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
-               .BuildParsed();
+    public static MethodOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
     }
-    
     public static Builder CreateBuilder() { return new Builder(); }
     public override Builder CreateBuilderForType() { return new Builder(); }
-    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions prototype) {
+    public static Builder CreateBuilder(MethodOptions prototype) {
       return (Builder) new Builder().MergeFrom(prototype);
     }
     
-    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, Builder> {
+    public sealed partial class Builder : pb::ExtendableBuilder<MethodOptions, Builder> {
       protected override Builder ThisBuilder {
         get { return this; }
       }
+      public Builder() {}
+      
+      MethodOptions result = new MethodOptions();
+      
+      protected override MethodOptions MessageBeingBuilt {
+        get { return result; }
+      }
+      
+      public override Builder Clear() {
+        result = new MethodOptions();
+        return this;
+      }
+      
+      public override Builder Clone() {
+        return new Builder().MergeFrom(result);
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return MethodOptions.Descriptor; }
+      }
+      
+      public override MethodOptions DefaultInstanceForType {
+        get { return MethodOptions.DefaultInstance; }
+      }
+      
+      public override MethodOptions BuildPartial() {
+        result.uninterpretedOption_.MakeReadOnly();
+        MethodOptions returnMe = result;
+        result = null;
+        return returnMe;
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is MethodOptions) {
+          return MergeFrom((MethodOptions) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(MethodOptions other) {
+        if (other == MethodOptions.DefaultInstance) return this;
+        if (other.uninterpretedOption_.Count != 0) {
+          base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_);
+        }
+        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 7994: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddUninterpretedOption(subBuilder.BuildPartial());
+              break;
+            }
+          }
+        }
+      }
+      
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList {
+        get { return result.uninterpretedOption_; }
+      }
+      public int UninterpretedOptionCount {
+        get { return result.UninterpretedOptionCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) {
+        return result.GetUninterpretedOption(index);
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_[index] = value;
+        return this;
+      }
+      public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) {
+        result.uninterpretedOption_.Add(value);
+        return this;
+      }
+      public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) {
+        result.uninterpretedOption_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) {
+        base.AddRange(values, result.uninterpretedOption_);
+        return this;
+      }
+      public Builder ClearUninterpretedOption() {
+        result.uninterpretedOption_.Clear();
+        return this;
+      }
+    }
+  }
+  
+  public sealed partial class UninterpretedOption : pb::GeneratedMessage<UninterpretedOption, UninterpretedOption.Builder> {
+    private static readonly UninterpretedOption defaultInstance = new Builder().BuildPartial();
+    public static UninterpretedOption DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override UninterpretedOption DefaultInstanceForType {
+      get { return defaultInstance; }
+    }
+    
+    protected override UninterpretedOption ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<UninterpretedOption, UninterpretedOption.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption__FieldAccessorTable; }
+    }
+    
+    #region Nested types
+    public static class Types {
+      public sealed partial class NamePart : pb::GeneratedMessage<NamePart, NamePart.Builder> {
+        private static readonly NamePart defaultInstance = new Builder().BuildPartial();
+        public static NamePart DefaultInstance {
+          get { return defaultInstance; }
+        }
+        
+        public override NamePart DefaultInstanceForType {
+          get { return defaultInstance; }
+        }
+        
+        protected override NamePart ThisMessage {
+          get { return this; }
+        }
+        
+        public static pbd::MessageDescriptor Descriptor {
+          get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor; }
+        }
+        
+        protected override pb::FieldAccess.FieldAccessorTable<NamePart, NamePart.Builder> InternalFieldAccessors {
+          get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption_NamePart__FieldAccessorTable; }
+        }
+        
+        private bool hasNamePart;
+        private string namePart_ = "";
+        public bool HasNamePart {
+          get { return hasNamePart; }
+        }
+        public string NamePart_ {
+          get { return namePart_; }
+        }
+        
+        private bool hasIsExtension;
+        private bool isExtension_ = false;
+        public bool HasIsExtension {
+          get { return hasIsExtension; }
+        }
+        public bool IsExtension {
+          get { return isExtension_; }
+        }
+        
+        public override bool IsInitialized {
+          get {
+            if (!hasNamePart) return false;
+            if (!hasIsExtension) return false;
+            return true;
+          }
+        }
+        
+        public override void WriteTo(pb::CodedOutputStream output) {
+          if (HasNamePart) {
+            output.WriteString(1, NamePart_);
+          }
+          if (HasIsExtension) {
+            output.WriteBool(2, IsExtension);
+          }
+          UnknownFields.WriteTo(output);
+        }
+        
+        private int memoizedSerializedSize = -1;
+        public override int SerializedSize {
+          get {
+            int size = memoizedSerializedSize;
+            if (size != -1) return size;
+            
+            size = 0;
+            if (HasNamePart) {
+              size += pb::CodedOutputStream.ComputeStringSize(1, NamePart_);
+            }
+            if (HasIsExtension) {
+              size += pb::CodedOutputStream.ComputeBoolSize(2, IsExtension);
+            }
+            size += UnknownFields.SerializedSize;
+            memoizedSerializedSize = size;
+            return size;
+          }
+        }
+        
+        public static NamePart ParseFrom(pb::ByteString data) {
+          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+        }
+        public static NamePart ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+        }
+        public static NamePart ParseFrom(byte[] data) {
+          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+        }
+        public static NamePart ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+        }
+        public static NamePart ParseFrom(global::System.IO.Stream input) {
+          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+        }
+        public static NamePart ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+        }
+        public static NamePart ParseFrom(pb::CodedInputStream input) {
+          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+        }
+        public static NamePart 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(NamePart prototype) {
+          return (Builder) new Builder().MergeFrom(prototype);
+        }
+        
+        public sealed partial class Builder : pb::GeneratedBuilder<NamePart, Builder> {
+          protected override Builder ThisBuilder {
+            get { return this; }
+          }
+          public Builder() {}
+          
+          NamePart result = new NamePart();
+          
+          protected override NamePart MessageBeingBuilt {
+            get { return result; }
+          }
+          
+          public override Builder Clear() {
+            result = new NamePart();
+            return this;
+          }
+          
+          public override Builder Clone() {
+            return new Builder().MergeFrom(result);
+          }
+          
+          public override pbd::MessageDescriptor DescriptorForType {
+            get { return NamePart.Descriptor; }
+          }
+          
+          public override NamePart DefaultInstanceForType {
+            get { return NamePart.DefaultInstance; }
+          }
+          
+          public override NamePart BuildPartial() {
+            NamePart returnMe = result;
+            result = null;
+            return returnMe;
+          }
+          
+          public override Builder MergeFrom(pb::IMessage other) {
+            if (other is NamePart) {
+              return MergeFrom((NamePart) other);
+            } else {
+              base.MergeFrom(other);
+              return this;
+            }
+          }
+          
+          public override Builder MergeFrom(NamePart other) {
+            if (other == NamePart.DefaultInstance) return this;
+            if (other.HasNamePart) {
+              NamePart_ = other.NamePart_;
+            }
+            if (other.HasIsExtension) {
+              IsExtension = other.IsExtension;
+            }
+            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: {
+                  NamePart_ = input.ReadString();
+                  break;
+                }
+                case 16: {
+                  IsExtension = input.ReadBool();
+                  break;
+                }
+              }
+            }
+          }
+          
+          
+          public bool HasNamePart {
+            get { return result.HasNamePart; }
+          }
+          public string NamePart_ {
+            get { return result.NamePart_; }
+            set { SetNamePart(value); }
+          }
+          public Builder SetNamePart(string value) {
+            result.hasNamePart = true;
+            result.namePart_ = value;
+            return this;
+          }
+          public Builder ClearNamePart() {
+            result.hasNamePart = false;
+            result.namePart_ = "";
+            return this;
+          }
+          
+          public bool HasIsExtension {
+            get { return result.HasIsExtension; }
+          }
+          public bool IsExtension {
+            get { return result.IsExtension; }
+            set { SetIsExtension(value); }
+          }
+          public Builder SetIsExtension(bool value) {
+            result.hasIsExtension = true;
+            result.isExtension_ = value;
+            return this;
+          }
+          public Builder ClearIsExtension() {
+            result.hasIsExtension = false;
+            result.isExtension_ = false;
+            return this;
+          }
+        }
+      }
       
-      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder()
+    }
+    #endregion
+    
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> name_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart>();
+    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> NameList {
+      get { return name_; }
+    }
+    public int NameCount {
+      get { return name_.Count; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart GetName(int index) {
+      return name_[index];
+    }
+    
+    private bool hasIdentifierValue;
+    private string identifierValue_ = "";
+    public bool HasIdentifierValue {
+      get { return hasIdentifierValue; }
+    }
+    public string IdentifierValue {
+      get { return identifierValue_; }
+    }
+    
+    private bool hasPositiveIntValue;
+    private ulong positiveIntValue_ = 0UL;
+    public bool HasPositiveIntValue {
+      get { return hasPositiveIntValue; }
+    }
+    public ulong PositiveIntValue {
+      get { return positiveIntValue_; }
+    }
+    
+    private bool hasNegativeIntValue;
+    private long negativeIntValue_ = 0L;
+    public bool HasNegativeIntValue {
+      get { return hasNegativeIntValue; }
+    }
+    public long NegativeIntValue {
+      get { return negativeIntValue_; }
+    }
+    
+    private bool hasDoubleValue;
+    private double doubleValue_ = 0D;
+    public bool HasDoubleValue {
+      get { return hasDoubleValue; }
+    }
+    public double DoubleValue {
+      get { return doubleValue_; }
+    }
+    
+    private bool hasStringValue;
+    private pb::ByteString stringValue_ = pb::ByteString.Empty;
+    public bool HasStringValue {
+      get { return hasStringValue; }
+    }
+    public pb::ByteString StringValue {
+      get { return stringValue_; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) {
+          if (!element.IsInitialized) return false;
+        }
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::CodedOutputStream output) {
+      foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) {
+        output.WriteMessage(2, element);
+      }
+      if (HasIdentifierValue) {
+        output.WriteString(3, IdentifierValue);
+      }
+      if (HasPositiveIntValue) {
+        output.WriteUInt64(4, PositiveIntValue);
+      }
+      if (HasNegativeIntValue) {
+        output.WriteInt64(5, NegativeIntValue);
+      }
+      if (HasDoubleValue) {
+        output.WriteDouble(6, DoubleValue);
+      }
+      if (HasStringValue) {
+        output.WriteBytes(7, StringValue);
+      }
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) {
+          size += pb::CodedOutputStream.ComputeMessageSize(2, element);
+        }
+        if (HasIdentifierValue) {
+          size += pb::CodedOutputStream.ComputeStringSize(3, IdentifierValue);
+        }
+        if (HasPositiveIntValue) {
+          size += pb::CodedOutputStream.ComputeUInt64Size(4, PositiveIntValue);
+        }
+        if (HasNegativeIntValue) {
+          size += pb::CodedOutputStream.ComputeInt64Size(5, NegativeIntValue);
+        }
+        if (HasDoubleValue) {
+          size += pb::CodedOutputStream.ComputeDoubleSize(6, DoubleValue);
+        }
+        if (HasStringValue) {
+          size += pb::CodedOutputStream.ComputeBytesSize(7, StringValue);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static UninterpretedOption ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static UninterpretedOption ParseFrom(pb::CodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static UninterpretedOption 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(UninterpretedOption prototype) {
+      return (Builder) new Builder().MergeFrom(prototype);
+    }
+    
+    public sealed partial class Builder : pb::GeneratedBuilder<UninterpretedOption, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
       public Builder() {}
       
-      global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions();
+      UninterpretedOption result = new UninterpretedOption();
       
-      protected override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions MessageBeingBuilt {
+      protected override UninterpretedOption MessageBeingBuilt {
         get { return result; }
       }
       
       public override Builder Clear() {
-        result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions();
+        result = new UninterpretedOption();
         return this;
       }
       
@@ -5464,30 +5895,49 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override pbd::MessageDescriptor DescriptorForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Descriptor; }
+        get { return UninterpretedOption.Descriptor; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions DefaultInstanceForType {
-        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance; }
+      public override UninterpretedOption DefaultInstanceForType {
+        get { return UninterpretedOption.DefaultInstance; }
       }
       
-      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions BuildPartial() {
-        global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions returnMe = result;
+      public override UninterpretedOption BuildPartial() {
+        result.name_.MakeReadOnly();
+        UninterpretedOption returnMe = result;
         result = null;
         return returnMe;
       }
       
       public override Builder MergeFrom(pb::IMessage other) {
-        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions) {
-          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions) other);
+        if (other is UninterpretedOption) {
+          return MergeFrom((UninterpretedOption) other);
         } else {
           base.MergeFrom(other);
           return this;
         }
       }
       
-      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions other) {
-        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) return this;
+      public override Builder MergeFrom(UninterpretedOption other) {
+        if (other == UninterpretedOption.DefaultInstance) return this;
+        if (other.name_.Count != 0) {
+          base.AddRange(other.name_, result.name_);
+        }
+        if (other.HasIdentifierValue) {
+          IdentifierValue = other.IdentifierValue;
+        }
+        if (other.HasPositiveIntValue) {
+          PositiveIntValue = other.PositiveIntValue;
+        }
+        if (other.HasNegativeIntValue) {
+          NegativeIntValue = other.NegativeIntValue;
+        }
+        if (other.HasDoubleValue) {
+          DoubleValue = other.DoubleValue;
+        }
+        if (other.HasStringValue) {
+          StringValue = other.StringValue;
+        }
         this.MergeUnknownFields(other.UnknownFields);
         return this;
       }
@@ -5497,31 +5947,178 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
       }
       
       public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
-        pb::UnknownFieldSet.Builder unknownFields =
-          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+        pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
         while (true) {
           uint tag = input.ReadTag();
           switch (tag) {
-            case 0:
+            case 0: {
               this.UnknownFields = unknownFields.Build();
               return this;
+            }
             default: {
-              if (!ParseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
+              if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {
                 this.UnknownFields = unknownFields.Build();
                 return this;
               }
               break;
             }
+            case 18: {
+              global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.CreateBuilder();
+              input.ReadMessage(subBuilder, extensionRegistry);
+              AddName(subBuilder.BuildPartial());
+              break;
+            }
+            case 26: {
+              IdentifierValue = input.ReadString();
+              break;
+            }
+            case 32: {
+              PositiveIntValue = input.ReadUInt64();
+              break;
+            }
+            case 40: {
+              NegativeIntValue = input.ReadInt64();
+              break;
+            }
+            case 49: {
+              DoubleValue = input.ReadDouble();
+              break;
+            }
+            case 58: {
+              StringValue = input.ReadBytes();
+              break;
+            }
           }
         }
       }
       
+      
+      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> NameList {
+        get { return result.name_; }
+      }
+      public int NameCount {
+        get { return result.NameCount; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart GetName(int index) {
+        return result.GetName(index);
+      }
+      public Builder SetName(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart value) {
+        result.name_[index] = value;
+        return this;
+      }
+      public Builder SetName(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder builderForValue) {
+        result.name_[index] = builderForValue.Build();
+        return this;
+      }
+      public Builder AddName(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart value) {
+        result.name_.Add(value);
+        return this;
+      }
+      public Builder AddName(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder builderForValue) {
+        result.name_.Add(builderForValue.Build());
+        return this;
+      }
+      public Builder AddRangeName(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> values) {
+        base.AddRange(values, result.name_);
+        return this;
+      }
+      public Builder ClearName() {
+        result.name_.Clear();
+        return this;
+      }
+      
+      public bool HasIdentifierValue {
+        get { return result.HasIdentifierValue; }
+      }
+      public string IdentifierValue {
+        get { return result.IdentifierValue; }
+        set { SetIdentifierValue(value); }
+      }
+      public Builder SetIdentifierValue(string value) {
+        result.hasIdentifierValue = true;
+        result.identifierValue_ = value;
+        return this;
+      }
+      public Builder ClearIdentifierValue() {
+        result.hasIdentifierValue = false;
+        result.identifierValue_ = "";
+        return this;
+      }
+      
+      public bool HasPositiveIntValue {
+        get { return result.HasPositiveIntValue; }
+      }
+      public ulong PositiveIntValue {
+        get { return result.PositiveIntValue; }
+        set { SetPositiveIntValue(value); }
+      }
+      public Builder SetPositiveIntValue(ulong value) {
+        result.hasPositiveIntValue = true;
+        result.positiveIntValue_ = value;
+        return this;
+      }
+      public Builder ClearPositiveIntValue() {
+        result.hasPositiveIntValue = false;
+        result.positiveIntValue_ = 0UL;
+        return this;
+      }
+      
+      public bool HasNegativeIntValue {
+        get { return result.HasNegativeIntValue; }
+      }
+      public long NegativeIntValue {
+        get { return result.NegativeIntValue; }
+        set { SetNegativeIntValue(value); }
+      }
+      public Builder SetNegativeIntValue(long value) {
+        result.hasNegativeIntValue = true;
+        result.negativeIntValue_ = value;
+        return this;
+      }
+      public Builder ClearNegativeIntValue() {
+        result.hasNegativeIntValue = false;
+        result.negativeIntValue_ = 0L;
+        return this;
+      }
+      
+      public bool HasDoubleValue {
+        get { return result.HasDoubleValue; }
+      }
+      public double DoubleValue {
+        get { return result.DoubleValue; }
+        set { SetDoubleValue(value); }
+      }
+      public Builder SetDoubleValue(double value) {
+        result.hasDoubleValue = true;
+        result.doubleValue_ = value;
+        return this;
+      }
+      public Builder ClearDoubleValue() {
+        result.hasDoubleValue = false;
+        result.doubleValue_ = 0D;
+        return this;
+      }
+      
+      public bool HasStringValue {
+        get { return result.HasStringValue; }
+      }
+      public pb::ByteString StringValue {
+        get { return result.StringValue; }
+        set { SetStringValue(value); }
+      }
+      public Builder SetStringValue(pb::ByteString value) {
+        result.hasStringValue = true;
+        result.stringValue_ = value;
+        return this;
+      }
+      public Builder ClearStringValue() {
+        result.hasStringValue = false;
+        result.stringValue_ = pb::ByteString.Empty;
+        return this;
+      }
     }
   }
   
   #endregion
   
-  #region Services
-  #endregion
 }
diff --git a/csharp/ProtocolBuffers/DescriptorProtos/PartialClasses.cs b/csharp/ProtocolBuffers/DescriptorProtos/PartialClasses.cs
index 66501374..5f414fc2 100644
--- a/csharp/ProtocolBuffers/DescriptorProtos/PartialClasses.cs
+++ b/csharp/ProtocolBuffers/DescriptorProtos/PartialClasses.cs
@@ -18,6 +18,21 @@
 // autogenerated classes, so that they implement
 // IDescriptorProto
 namespace Google.ProtocolBuffers.DescriptorProtos {
+
+  // TODO(jonskeet): Find a better way of fixing this. It's needed in order to
+  // cope with unknown fields during initialization.
+  public partial class DescriptorProtoFile {
+    private static readonly bool initialized = false;
+
+    internal static bool Bootstrapping {
+      get { return !initialized; }
+    }
+
+    static DescriptorProtoFile() {
+      initialized = true;
+    }
+  }
+
   public partial class DescriptorProto : IDescriptorProto<MessageOptions> { }
   public partial class EnumDescriptorProto : IDescriptorProto<EnumOptions> { }
   public partial class EnumValueDescriptorProto : IDescriptorProto<EnumValueOptions> { }
diff --git a/csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs b/csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs
index 3fa3360e..abd54e76 100644
--- a/csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs
+++ b/csharp/ProtocolBuffers/Descriptors/FileDescriptor.cs
@@ -181,7 +181,7 @@ namespace Google.ProtocolBuffers.Descriptors {
     /// a valid descriptor. This can occur for a number of reasons, such as a field
     /// having an undefined type or because two messages were defined with the same name.</exception>
     public static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies) {
-      // Building decsriptors involves two steps:  translating and linking.
+      // Building descriptors involves two steps: translating and linking.
       // In the translation step (implemented by FileDescriptor's
       // constructor), we build an object tree mirroring the
       // FileDescriptorProto's tree and put all of the descriptors into the
@@ -204,9 +204,9 @@ namespace Google.ProtocolBuffers.Descriptors {
       }
       for (int i = 0; i < proto.DependencyCount; i++) {
         if (dependencies[i].Name != proto.DependencyList[i]) {
-          throw new DescriptorValidationException(result,
+          /*throw new DescriptorValidationException(result,
             "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
-            "those listed in the FileDescriptorProto.");
+            "those listed in the FileDescriptorProto.");*/
         }
       }
 
diff --git a/csharp/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs b/csharp/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs
index 33def0a7..35a2a204 100644
--- a/csharp/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs
+++ b/csharp/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs
@@ -48,7 +48,7 @@ namespace Google.ProtocolBuffers.FieldAccess {
       PropertyInfo messageProperty = typeof(TMessage).GetProperty(name + "List");
       PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name + "List");
       PropertyInfo countProperty = typeof(TMessage).GetProperty(name + "Count");
-      MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name);
+      MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, Type.EmptyTypes);
       getElementMethod = typeof(TMessage).GetMethod("Get" + name, new Type[] { typeof(int) });
       clrType = getElementMethod.ReturnType;
       MethodInfo addMethod = typeof(TBuilder).GetMethod("Add" + name, new Type[] { ClrType });
diff --git a/csharp/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs b/csharp/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs
index ad9e1659..c10936d4 100644
--- a/csharp/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs
+++ b/csharp/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs
@@ -39,10 +39,13 @@ namespace Google.ProtocolBuffers.FieldAccess {
     }
 
     internal SinglePrimitiveAccessor(string name) {
-      PropertyInfo messageProperty = typeof(TMessage).GetProperty(name);
-      PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name);
+
+      string propertyName = name == typeof(TMessage).Name ? name + "_" : name;
+      PropertyInfo messageProperty = typeof(TMessage).GetProperty(propertyName);
+      PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name); // FIXME!
+      if (builderProperty == null) builderProperty = typeof(TBuilder).GetProperty(propertyName); // FIXME!
       PropertyInfo hasProperty = typeof(TMessage).GetProperty("Has" + name);
-      MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name);
+      MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, Type.EmptyTypes);
       if (messageProperty == null || builderProperty == null || hasProperty == null || clearMethod == null) {
         throw new ArgumentException("Not all required properties/methods available");
       }
diff --git a/csharp/ProtocolBuffers/FieldSet.cs b/csharp/ProtocolBuffers/FieldSet.cs
index 54d7b1c3..c130d858 100644
--- a/csharp/ProtocolBuffers/FieldSet.cs
+++ b/csharp/ProtocolBuffers/FieldSet.cs
@@ -33,6 +33,7 @@ namespace Google.ProtocolBuffers {
   /// be impossible to guarantee if this were a public class, of course.
   /// 
   /// All repeated fields are stored as IList[object] even 
+  /// TODO(jonskeet): Finish this comment!
   /// </summary>
   internal sealed class FieldSet {
 
diff --git a/csharp/ProtocolBuffers/ProtocolBuffers.csproj b/csharp/ProtocolBuffers/ProtocolBuffers.csproj
index f68e761a..3f76aa7f 100644
--- a/csharp/ProtocolBuffers/ProtocolBuffers.csproj
+++ b/csharp/ProtocolBuffers/ProtocolBuffers.csproj
@@ -48,6 +48,7 @@
     <Compile Include="Collections\Dictionaries.cs" />
     <Compile Include="Collections\Lists.cs" />
     <Compile Include="Collections\ReadOnlyDictionary.cs" />
+    <Compile Include="DescriptorProtos\CSharpOptions.cs" />
     <Compile Include="DescriptorProtos\DescriptorProtoFile.cs" />
     <Compile Include="DescriptorProtos\IDescriptorProto.cs" />
     <Compile Include="DescriptorProtos\PartialClasses.cs" />
diff --git a/csharp/ProtocolBuffers/TextGenerator.cs b/csharp/ProtocolBuffers/TextGenerator.cs
index 3cb8b490..fb0f66dd 100644
--- a/csharp/ProtocolBuffers/TextGenerator.cs
+++ b/csharp/ProtocolBuffers/TextGenerator.cs
@@ -97,6 +97,10 @@ namespace Google.ProtocolBuffers {
       Write(text.Substring(pos));
     }
 
+    public void Write(string format, params object[] args) {
+      Write(string.Format(format, args));
+    }
+    
     private void Write(string data) {
       if (data.Length == 0) {
         return;
diff --git a/csharp/ProtocolBuffers/UnknownFieldSet.cs b/csharp/ProtocolBuffers/UnknownFieldSet.cs
index 3d3e38ea..18eacbe8 100644
--- a/csharp/ProtocolBuffers/UnknownFieldSet.cs
+++ b/csharp/ProtocolBuffers/UnknownFieldSet.cs
@@ -18,6 +18,7 @@ using System.Collections.Generic;
 using System.IO;
 using Google.ProtocolBuffers.Collections;
 using Google.ProtocolBuffers.Descriptors;
+using Google.ProtocolBuffers.DescriptorProtos;
 
 namespace Google.ProtocolBuffers {
   /// <summary>
@@ -454,6 +455,11 @@ namespace Google.ProtocolBuffers {
       /// <returns>true unless the tag is an end-group tag</returns>
       internal bool MergeFieldFrom(CodedInputStream input, 
           ExtensionRegistry extensionRegistry, IBuilder builder, uint tag) {
+
+        if (DescriptorProtoFile.Bootstrapping) {
+          return MergeFieldFrom(tag, input);
+        }
+
         MessageDescriptor type = builder.DescriptorForType;
         if (type.Options.MessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) {
           MergeMessageSetExtensionFromCodedStream(input, extensionRegistry, builder);