Person.cs

// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=55f7125234beb589.  DO NOT EDIT!
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Proto {
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public static partial class Person {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
    }
    #endregion
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_Passport__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Passport, global::Passport.Builder> internal__static_Passport__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_PoliceRecord__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::PoliceRecord, global::PoliceRecord.Builder> internal__static_PoliceRecord__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Person__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Person, global::Person.Builder> internal__static_Person__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Node__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Node, global::Node.Builder> internal__static_Node__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static Person() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          "CgxwZXJzb24ucHJvdG8iLQoIUGFzc3BvcnQSDgoGbnVtYmVyGAEgAigJEhEK" + 
          "CWF1dGhvcml0eRgCIAIoCSIpCgxQb2xpY2VSZWNvcmQSCgoCaWQYASACKAUS" + 
          "DQoFY3JpbWUYAiACKAkilwEKBlBlcnNvbhIRCglmaXJzdE5hbWUYASACKAkS" + 
          "EAoIbGFzdE5hbWUYAiACKAkSCwoDYWdlGAMgAigFEhcKBmdlbmRlchgEIAIo" + 
          "DjIHLkdlbmRlchIbCghwYXNzcG9ydBgFIAEoCzIJLlBhc3Nwb3J0EiUKDnBv" + 
          "bGljZV9yZWNvcmRzGAYgAygLMg0uUG9saWNlUmVjb3JkIj8KBE5vZGUSDAoE" + 
          "ZGF0YRgBIAIoBRITCgRsZWZ0GAIgASgLMgUuTm9kZRIUCgVyaWdodBgDIAEo" + 
          "CzIFLk5vZGUqHgoGR2VuZGVyEggKBE1hbGUQABIKCgZGZW1hbGUQAQ==");
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_Passport__Descriptor = Descriptor.MessageTypes[0];
        internal__static_Passport__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Passport, global::Passport.Builder>(internal__static_Passport__Descriptor,
                new string[] { "Number", "Authority", });
        internal__static_PoliceRecord__Descriptor = Descriptor.MessageTypes[1];
        internal__static_PoliceRecord__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::PoliceRecord, global::PoliceRecord.Builder>(internal__static_PoliceRecord__Descriptor,
                new string[] { "Id", "Crime", });
        internal__static_Person__Descriptor = Descriptor.MessageTypes[2];
        internal__static_Person__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Person, global::Person.Builder>(internal__static_Person__Descriptor,
                new string[] { "FirstName", "LastName", "Age", "Gender", "Passport", "PoliceRecords", });
        internal__static_Node__Descriptor = Descriptor.MessageTypes[3];
        internal__static_Node__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Node, global::Node.Builder>(internal__static_Node__Descriptor,
                new string[] { "Data", "Left", "Right", });
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          }, assigner);
    }
    #endregion
    
  }
}
#region Enums
public enum Gender {
  Male = 0,
  Female = 1,
}

#endregion

#region Messages
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Passport : pb::GeneratedMessage<Passport, Passport.Builder> {
  private Passport() { }
  private static readonly Passport defaultInstance = new Passport().MakeReadOnly();
  private static readonly string[] _passportFieldNames = new string[] { "authority", "number" };
  private static readonly uint[] _passportFieldTags = new uint[] { 18, 10 };
  public static Passport DefaultInstance {
    get { return defaultInstance; }
  }
  
  public override Passport DefaultInstanceForType {
    get { return DefaultInstance; }
  }
  
  protected override Passport ThisMessage {
    get { return this; }
  }
  
  public static pbd::MessageDescriptor Descriptor {
    get { return global::Proto.Person.internal__static_Passport__Descriptor; }
  }
  
  protected override pb::FieldAccess.FieldAccessorTable<Passport, Passport.Builder> InternalFieldAccessors {
    get { return global::Proto.Person.internal__static_Passport__FieldAccessorTable; }
  }
  
  public const int NumberFieldNumber = 1;
  private bool hasNumber;
  private string number_ = "";
  public bool HasNumber {
    get { return hasNumber; }
  }
  public string Number {
    get { return number_; }
  }
  
  public const int AuthorityFieldNumber = 2;
  private bool hasAuthority;
  private string authority_ = "";
  public bool HasAuthority {
    get { return hasAuthority; }
  }
  public string Authority {
    get { return authority_; }
  }
  
  public override bool IsInitialized {
    get {
      if (!hasNumber) return false;
      if (!hasAuthority) return false;
      return true;
    }
  }
  
  public override void WriteTo(pb::ICodedOutputStream output) {
    int size = SerializedSize;
    string[] field_names = _passportFieldNames;
    if (hasNumber) {
      output.WriteString(1, field_names[1], Number);
    }
    if (hasAuthority) {
      output.WriteString(2, field_names[0], Authority);
    }
    UnknownFields.WriteTo(output);
  }
  
  private int memoizedSerializedSize = -1;
  public override int SerializedSize {
    get {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasNumber) {
        size += pb::CodedOutputStream.ComputeStringSize(1, Number);
      }
      if (hasAuthority) {
        size += pb::CodedOutputStream.ComputeStringSize(2, Authority);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
  }
  
  public static Passport ParseFrom(pb::ByteString data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Passport ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Passport ParseFrom(byte[] data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Passport ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Passport ParseFrom(global::System.IO.Stream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Passport ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  public static Passport ParseDelimitedFrom(global::System.IO.Stream input) {
    return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
  }
  public static Passport ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
  }
  public static Passport ParseFrom(pb::ICodedInputStream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Passport ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  private Passport MakeReadOnly() {
    return this;
  }
  
  public static Builder CreateBuilder() { return new Builder(); }
  public override Builder ToBuilder() { return CreateBuilder(this); }
  public override Builder CreateBuilderForType() { return new Builder(); }
  public static Builder CreateBuilder(Passport prototype) {
    return new Builder(prototype);
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class Builder : pb::GeneratedBuilder<Passport, Builder> {
    protected override Builder ThisBuilder {
      get { return this; }
    }
    public Builder() {
      result = DefaultInstance;
      resultIsReadOnly = true;
    }
    internal Builder(Passport cloneFrom) {
      result = cloneFrom;
      resultIsReadOnly = true;
    }
    
    private bool resultIsReadOnly;
    private Passport result;
    
    private Passport PrepareBuilder() {
      if (resultIsReadOnly) {
        Passport original = result;
        result = new Passport();
        resultIsReadOnly = false;
        MergeFrom(original);
      }
      return result;
    }
    
    public override bool IsInitialized {
      get { return result.IsInitialized; }
    }
    
    protected override Passport MessageBeingBuilt {
      get { return PrepareBuilder(); }
    }
    
    public override Builder Clear() {
      result = DefaultInstance;
      resultIsReadOnly = true;
      return this;
    }
    
    public override Builder Clone() {
      if (resultIsReadOnly) {
        return new Builder(result);
      } else {
        return new Builder().MergeFrom(result);
      }
    }
    
    public override pbd::MessageDescriptor DescriptorForType {
      get { return global::Passport.Descriptor; }
    }
    
    public override Passport DefaultInstanceForType {
      get { return global::Passport.DefaultInstance; }
    }
    
    public override Passport BuildPartial() {
      if (resultIsReadOnly) {
        return result;
      }
      resultIsReadOnly = true;
      return result.MakeReadOnly();
    }
    
    public override Builder MergeFrom(pb::IMessage other) {
      if (other is Passport) {
        return MergeFrom((Passport) other);
      } else {
        base.MergeFrom(other);
        return this;
      }
    }
    
    public override Builder MergeFrom(Passport other) {
      if (other == global::Passport.DefaultInstance) return this;
      PrepareBuilder();
      if (other.HasNumber) {
        Number = other.Number;
      }
      if (other.HasAuthority) {
        Authority = other.Authority;
      }
      this.MergeUnknownFields(other.UnknownFields);
      return this;
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input) {
      return MergeFrom(input, pb::ExtensionRegistry.Empty);
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      PrepareBuilder();
      pb::UnknownFieldSet.Builder unknownFields = null;
      uint tag;
      string field_name;
      while (input.ReadTag(out tag, out field_name)) {
        if(tag == 0 && field_name != null) {
          int field_ordinal = global::System.Array.BinarySearch(_passportFieldNames, field_name, global::System.StringComparer.Ordinal);
          if(field_ordinal >= 0)
            tag = _passportFieldTags[field_ordinal];
          else {
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            continue;
          }
        }
        switch (tag) {
          case 0: {
            throw pb::InvalidProtocolBufferException.InvalidTag();
          }
          default: {
            if (pb::WireFormat.IsEndGroupTag(tag)) {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            break;
          }
          case 10: {
            result.hasNumber = input.ReadString(ref result.number_);
            break;
          }
          case 18: {
            result.hasAuthority = input.ReadString(ref result.authority_);
            break;
          }
        }
      }
      
      if (unknownFields != null) {
        this.UnknownFields = unknownFields.Build();
      }
      return this;
    }
    
    
    public bool HasNumber {
      get { return result.hasNumber; }
    }
    public string Number {
      get { return result.Number; }
      set { SetNumber(value); }
    }
    public Builder SetNumber(string value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasNumber = true;
      result.number_ = value;
      return this;
    }
    public Builder ClearNumber() {
      PrepareBuilder();
      result.hasNumber = false;
      result.number_ = "";
      return this;
    }
    
    public bool HasAuthority {
      get { return result.hasAuthority; }
    }
    public string Authority {
      get { return result.Authority; }
      set { SetAuthority(value); }
    }
    public Builder SetAuthority(string value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasAuthority = true;
      result.authority_ = value;
      return this;
    }
    public Builder ClearAuthority() {
      PrepareBuilder();
      result.hasAuthority = false;
      result.authority_ = "";
      return this;
    }
  }
  static Passport() {
    object.ReferenceEquals(global::Proto.Person.Descriptor, null);
  }
}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class PoliceRecord : pb::GeneratedMessage<PoliceRecord, PoliceRecord.Builder> {
  private PoliceRecord() { }
  private static readonly PoliceRecord defaultInstance = new PoliceRecord().MakeReadOnly();
  private static readonly string[] _policeRecordFieldNames = new string[] { "crime", "id" };
  private static readonly uint[] _policeRecordFieldTags = new uint[] { 18, 8 };
  public static PoliceRecord DefaultInstance {
    get { return defaultInstance; }
  }
  
  public override PoliceRecord DefaultInstanceForType {
    get { return DefaultInstance; }
  }
  
  protected override PoliceRecord ThisMessage {
    get { return this; }
  }
  
  public static pbd::MessageDescriptor Descriptor {
    get { return global::Proto.Person.internal__static_PoliceRecord__Descriptor; }
  }
  
  protected override pb::FieldAccess.FieldAccessorTable<PoliceRecord, PoliceRecord.Builder> InternalFieldAccessors {
    get { return global::Proto.Person.internal__static_PoliceRecord__FieldAccessorTable; }
  }
  
  public const int IdFieldNumber = 1;
  private bool hasId;
  private int id_;
  public bool HasId {
    get { return hasId; }
  }
  public int Id {
    get { return id_; }
  }
  
  public const int CrimeFieldNumber = 2;
  private bool hasCrime;
  private string crime_ = "";
  public bool HasCrime {
    get { return hasCrime; }
  }
  public string Crime {
    get { return crime_; }
  }
  
  public override bool IsInitialized {
    get {
      if (!hasId) return false;
      if (!hasCrime) return false;
      return true;
    }
  }
  
  public override void WriteTo(pb::ICodedOutputStream output) {
    int size = SerializedSize;
    string[] field_names = _policeRecordFieldNames;
    if (hasId) {
      output.WriteInt32(1, field_names[1], Id);
    }
    if (hasCrime) {
      output.WriteString(2, field_names[0], Crime);
    }
    UnknownFields.WriteTo(output);
  }
  
  private int memoizedSerializedSize = -1;
  public override int SerializedSize {
    get {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasId) {
        size += pb::CodedOutputStream.ComputeInt32Size(1, Id);
      }
      if (hasCrime) {
        size += pb::CodedOutputStream.ComputeStringSize(2, Crime);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
  }
  
  public static PoliceRecord ParseFrom(pb::ByteString data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(byte[] data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(global::System.IO.Stream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  public static PoliceRecord ParseDelimitedFrom(global::System.IO.Stream input) {
    return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
  }
  public static PoliceRecord ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
  }
  public static PoliceRecord ParseFrom(pb::ICodedInputStream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static PoliceRecord ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  private PoliceRecord MakeReadOnly() {
    return this;
  }
  
  public static Builder CreateBuilder() { return new Builder(); }
  public override Builder ToBuilder() { return CreateBuilder(this); }
  public override Builder CreateBuilderForType() { return new Builder(); }
  public static Builder CreateBuilder(PoliceRecord prototype) {
    return new Builder(prototype);
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class Builder : pb::GeneratedBuilder<PoliceRecord, Builder> {
    protected override Builder ThisBuilder {
      get { return this; }
    }
    public Builder() {
      result = DefaultInstance;
      resultIsReadOnly = true;
    }
    internal Builder(PoliceRecord cloneFrom) {
      result = cloneFrom;
      resultIsReadOnly = true;
    }
    
    private bool resultIsReadOnly;
    private PoliceRecord result;
    
    private PoliceRecord PrepareBuilder() {
      if (resultIsReadOnly) {
        PoliceRecord original = result;
        result = new PoliceRecord();
        resultIsReadOnly = false;
        MergeFrom(original);
      }
      return result;
    }
    
    public override bool IsInitialized {
      get { return result.IsInitialized; }
    }
    
    protected override PoliceRecord MessageBeingBuilt {
      get { return PrepareBuilder(); }
    }
    
    public override Builder Clear() {
      result = DefaultInstance;
      resultIsReadOnly = true;
      return this;
    }
    
    public override Builder Clone() {
      if (resultIsReadOnly) {
        return new Builder(result);
      } else {
        return new Builder().MergeFrom(result);
      }
    }
    
    public override pbd::MessageDescriptor DescriptorForType {
      get { return global::PoliceRecord.Descriptor; }
    }
    
    public override PoliceRecord DefaultInstanceForType {
      get { return global::PoliceRecord.DefaultInstance; }
    }
    
    public override PoliceRecord BuildPartial() {
      if (resultIsReadOnly) {
        return result;
      }
      resultIsReadOnly = true;
      return result.MakeReadOnly();
    }
    
    public override Builder MergeFrom(pb::IMessage other) {
      if (other is PoliceRecord) {
        return MergeFrom((PoliceRecord) other);
      } else {
        base.MergeFrom(other);
        return this;
      }
    }
    
    public override Builder MergeFrom(PoliceRecord other) {
      if (other == global::PoliceRecord.DefaultInstance) return this;
      PrepareBuilder();
      if (other.HasId) {
        Id = other.Id;
      }
      if (other.HasCrime) {
        Crime = other.Crime;
      }
      this.MergeUnknownFields(other.UnknownFields);
      return this;
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input) {
      return MergeFrom(input, pb::ExtensionRegistry.Empty);
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      PrepareBuilder();
      pb::UnknownFieldSet.Builder unknownFields = null;
      uint tag;
      string field_name;
      while (input.ReadTag(out tag, out field_name)) {
        if(tag == 0 && field_name != null) {
          int field_ordinal = global::System.Array.BinarySearch(_policeRecordFieldNames, field_name, global::System.StringComparer.Ordinal);
          if(field_ordinal >= 0)
            tag = _policeRecordFieldTags[field_ordinal];
          else {
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            continue;
          }
        }
        switch (tag) {
          case 0: {
            throw pb::InvalidProtocolBufferException.InvalidTag();
          }
          default: {
            if (pb::WireFormat.IsEndGroupTag(tag)) {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            break;
          }
          case 8: {
            result.hasId = input.ReadInt32(ref result.id_);
            break;
          }
          case 18: {
            result.hasCrime = input.ReadString(ref result.crime_);
            break;
          }
        }
      }
      
      if (unknownFields != null) {
        this.UnknownFields = unknownFields.Build();
      }
      return this;
    }
    
    
    public bool HasId {
      get { return result.hasId; }
    }
    public int Id {
      get { return result.Id; }
      set { SetId(value); }
    }
    public Builder SetId(int value) {
      PrepareBuilder();
      result.hasId = true;
      result.id_ = value;
      return this;
    }
    public Builder ClearId() {
      PrepareBuilder();
      result.hasId = false;
      result.id_ = 0;
      return this;
    }
    
    public bool HasCrime {
      get { return result.hasCrime; }
    }
    public string Crime {
      get { return result.Crime; }
      set { SetCrime(value); }
    }
    public Builder SetCrime(string value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasCrime = true;
      result.crime_ = value;
      return this;
    }
    public Builder ClearCrime() {
      PrepareBuilder();
      result.hasCrime = false;
      result.crime_ = "";
      return this;
    }
  }
  static PoliceRecord() {
    object.ReferenceEquals(global::Proto.Person.Descriptor, null);
  }
}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Person : pb::GeneratedMessage<Person, Person.Builder> {
  private Person() { }
  private static readonly Person defaultInstance = new Person().MakeReadOnly();
  private static readonly string[] _personFieldNames = new string[] { "age", "firstName", "gender", "lastName", "passport", "police_records" };
  private static readonly uint[] _personFieldTags = new uint[] { 24, 10, 32, 18, 42, 50 };
  public static Person DefaultInstance {
    get { return defaultInstance; }
  }
  
  public override Person DefaultInstanceForType {
    get { return DefaultInstance; }
  }
  
  protected override Person ThisMessage {
    get { return this; }
  }
  
  public static pbd::MessageDescriptor Descriptor {
    get { return global::Proto.Person.internal__static_Person__Descriptor; }
  }
  
  protected override pb::FieldAccess.FieldAccessorTable<Person, Person.Builder> InternalFieldAccessors {
    get { return global::Proto.Person.internal__static_Person__FieldAccessorTable; }
  }
  
  public const int FirstNameFieldNumber = 1;
  private bool hasFirstName;
  private string firstName_ = "";
  public bool HasFirstName {
    get { return hasFirstName; }
  }
  public string FirstName {
    get { return firstName_; }
  }
  
  public const int LastNameFieldNumber = 2;
  private bool hasLastName;
  private string lastName_ = "";
  public bool HasLastName {
    get { return hasLastName; }
  }
  public string LastName {
    get { return lastName_; }
  }
  
  public const int AgeFieldNumber = 3;
  private bool hasAge;
  private int age_;
  public bool HasAge {
    get { return hasAge; }
  }
  public int Age {
    get { return age_; }
  }
  
  public const int GenderFieldNumber = 4;
  private bool hasGender;
  private global::Gender gender_ = global::Gender.Male;
  public bool HasGender {
    get { return hasGender; }
  }
  public global::Gender Gender {
    get { return gender_; }
  }
  
  public const int PassportFieldNumber = 5;
  private bool hasPassport;
  private global::Passport passport_;
  public bool HasPassport {
    get { return hasPassport; }
  }
  public global::Passport Passport {
    get { return passport_ ?? global::Passport.DefaultInstance; }
  }
  
  public const int PoliceRecordsFieldNumber = 6;
  private pbc::PopsicleList<global::PoliceRecord> policeRecords_ = new pbc::PopsicleList<global::PoliceRecord>();
  public scg::IList<global::PoliceRecord> PoliceRecordsList {
    get { return policeRecords_; }
  }
  public int PoliceRecordsCount {
    get { return policeRecords_.Count; }
  }
  public global::PoliceRecord GetPoliceRecords(int index) {
    return policeRecords_[index];
  }
  
  public override bool IsInitialized {
    get {
      if (!hasFirstName) return false;
      if (!hasLastName) return false;
      if (!hasAge) return false;
      if (!hasGender) return false;
      if (HasPassport) {
        if (!Passport.IsInitialized) return false;
      }
      foreach (global::PoliceRecord element in PoliceRecordsList) {
        if (!element.IsInitialized) return false;
      }
      return true;
    }
  }
  
  public override void WriteTo(pb::ICodedOutputStream output) {
    int size = SerializedSize;
    string[] field_names = _personFieldNames;
    if (hasFirstName) {
      output.WriteString(1, field_names[1], FirstName);
    }
    if (hasLastName) {
      output.WriteString(2, field_names[3], LastName);
    }
    if (hasAge) {
      output.WriteInt32(3, field_names[0], Age);
    }
    if (hasGender) {
      output.WriteEnum(4, field_names[2], (int) Gender, Gender);
    }
    if (hasPassport) {
      output.WriteMessage(5, field_names[4], Passport);
    }
    if (policeRecords_.Count > 0) {
      output.WriteMessageArray(6, field_names[5], policeRecords_);
    }
    UnknownFields.WriteTo(output);
  }
  
  private int memoizedSerializedSize = -1;
  public override int SerializedSize {
    get {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasFirstName) {
        size += pb::CodedOutputStream.ComputeStringSize(1, FirstName);
      }
      if (hasLastName) {
        size += pb::CodedOutputStream.ComputeStringSize(2, LastName);
      }
      if (hasAge) {
        size += pb::CodedOutputStream.ComputeInt32Size(3, Age);
      }
      if (hasGender) {
        size += pb::CodedOutputStream.ComputeEnumSize(4, (int) Gender);
      }
      if (hasPassport) {
        size += pb::CodedOutputStream.ComputeMessageSize(5, Passport);
      }
      foreach (global::PoliceRecord element in PoliceRecordsList) {
        size += pb::CodedOutputStream.ComputeMessageSize(6, element);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
  }
  
  public static Person ParseFrom(pb::ByteString data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Person ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Person ParseFrom(byte[] data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Person ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Person ParseFrom(global::System.IO.Stream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Person ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  public static Person ParseDelimitedFrom(global::System.IO.Stream input) {
    return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
  }
  public static Person ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
  }
  public static Person ParseFrom(pb::ICodedInputStream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Person ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  private Person MakeReadOnly() {
    policeRecords_.MakeReadOnly();
    return this;
  }
  
  public static Builder CreateBuilder() { return new Builder(); }
  public override Builder ToBuilder() { return CreateBuilder(this); }
  public override Builder CreateBuilderForType() { return new Builder(); }
  public static Builder CreateBuilder(Person prototype) {
    return new Builder(prototype);
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class Builder : pb::GeneratedBuilder<Person, Builder> {
    protected override Builder ThisBuilder {
      get { return this; }
    }
    public Builder() {
      result = DefaultInstance;
      resultIsReadOnly = true;
    }
    internal Builder(Person cloneFrom) {
      result = cloneFrom;
      resultIsReadOnly = true;
    }
    
    private bool resultIsReadOnly;
    private Person result;
    
    private Person PrepareBuilder() {
      if (resultIsReadOnly) {
        Person original = result;
        result = new Person();
        resultIsReadOnly = false;
        MergeFrom(original);
      }
      return result;
    }
    
    public override bool IsInitialized {
      get { return result.IsInitialized; }
    }
    
    protected override Person MessageBeingBuilt {
      get { return PrepareBuilder(); }
    }
    
    public override Builder Clear() {
      result = DefaultInstance;
      resultIsReadOnly = true;
      return this;
    }
    
    public override Builder Clone() {
      if (resultIsReadOnly) {
        return new Builder(result);
      } else {
        return new Builder().MergeFrom(result);
      }
    }
    
    public override pbd::MessageDescriptor DescriptorForType {
      get { return global::Person.Descriptor; }
    }
    
    public override Person DefaultInstanceForType {
      get { return global::Person.DefaultInstance; }
    }
    
    public override Person BuildPartial() {
      if (resultIsReadOnly) {
        return result;
      }
      resultIsReadOnly = true;
      return result.MakeReadOnly();
    }
    
    public override Builder MergeFrom(pb::IMessage other) {
      if (other is Person) {
        return MergeFrom((Person) other);
      } else {
        base.MergeFrom(other);
        return this;
      }
    }
    
    public override Builder MergeFrom(Person other) {
      if (other == global::Person.DefaultInstance) return this;
      PrepareBuilder();
      if (other.HasFirstName) {
        FirstName = other.FirstName;
      }
      if (other.HasLastName) {
        LastName = other.LastName;
      }
      if (other.HasAge) {
        Age = other.Age;
      }
      if (other.HasGender) {
        Gender = other.Gender;
      }
      if (other.HasPassport) {
        MergePassport(other.Passport);
      }
      if (other.policeRecords_.Count != 0) {
        result.policeRecords_.Add(other.policeRecords_);
      }
      this.MergeUnknownFields(other.UnknownFields);
      return this;
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input) {
      return MergeFrom(input, pb::ExtensionRegistry.Empty);
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      PrepareBuilder();
      pb::UnknownFieldSet.Builder unknownFields = null;
      uint tag;
      string field_name;
      while (input.ReadTag(out tag, out field_name)) {
        if(tag == 0 && field_name != null) {
          int field_ordinal = global::System.Array.BinarySearch(_personFieldNames, field_name, global::System.StringComparer.Ordinal);
          if(field_ordinal >= 0)
            tag = _personFieldTags[field_ordinal];
          else {
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            continue;
          }
        }
        switch (tag) {
          case 0: {
            throw pb::InvalidProtocolBufferException.InvalidTag();
          }
          default: {
            if (pb::WireFormat.IsEndGroupTag(tag)) {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            break;
          }
          case 10: {
            result.hasFirstName = input.ReadString(ref result.firstName_);
            break;
          }
          case 18: {
            result.hasLastName = input.ReadString(ref result.lastName_);
            break;
          }
          case 24: {
            result.hasAge = input.ReadInt32(ref result.age_);
            break;
          }
          case 32: {
            object unknown;
            if(input.ReadEnum(ref result.gender_, out unknown)) {
              result.hasGender = true;
            } else if(unknown is int) {
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              unknownFields.MergeVarintField(4, (ulong)(int)unknown);
            }
            break;
          }
          case 42: {
            global::Passport.Builder subBuilder = global::Passport.CreateBuilder();
            if (result.hasPassport) {
              subBuilder.MergeFrom(Passport);
            }
            input.ReadMessage(subBuilder, extensionRegistry);
            Passport = subBuilder.BuildPartial();
            break;
          }
          case 50: {
            input.ReadMessageArray(tag, field_name, result.policeRecords_, global::PoliceRecord.DefaultInstance, extensionRegistry);
            break;
          }
        }
      }
      
      if (unknownFields != null) {
        this.UnknownFields = unknownFields.Build();
      }
      return this;
    }
    
    
    public bool HasFirstName {
      get { return result.hasFirstName; }
    }
    public string FirstName {
      get { return result.FirstName; }
      set { SetFirstName(value); }
    }
    public Builder SetFirstName(string value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasFirstName = true;
      result.firstName_ = value;
      return this;
    }
    public Builder ClearFirstName() {
      PrepareBuilder();
      result.hasFirstName = false;
      result.firstName_ = "";
      return this;
    }
    
    public bool HasLastName {
      get { return result.hasLastName; }
    }
    public string LastName {
      get { return result.LastName; }
      set { SetLastName(value); }
    }
    public Builder SetLastName(string value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasLastName = true;
      result.lastName_ = value;
      return this;
    }
    public Builder ClearLastName() {
      PrepareBuilder();
      result.hasLastName = false;
      result.lastName_ = "";
      return this;
    }
    
    public bool HasAge {
      get { return result.hasAge; }
    }
    public int Age {
      get { return result.Age; }
      set { SetAge(value); }
    }
    public Builder SetAge(int value) {
      PrepareBuilder();
      result.hasAge = true;
      result.age_ = value;
      return this;
    }
    public Builder ClearAge() {
      PrepareBuilder();
      result.hasAge = false;
      result.age_ = 0;
      return this;
    }
    
    public bool HasGender {
     get { return result.hasGender; }
    }
    public global::Gender Gender {
      get { return result.Gender; }
      set { SetGender(value); }
    }
    public Builder SetGender(global::Gender value) {
      PrepareBuilder();
      result.hasGender = true;
      result.gender_ = value;
      return this;
    }
    public Builder ClearGender() {
      PrepareBuilder();
      result.hasGender = false;
      result.gender_ = global::Gender.Male;
      return this;
    }
    
    public bool HasPassport {
     get { return result.hasPassport; }
    }
    public global::Passport Passport {
      get { return result.Passport; }
      set { SetPassport(value); }
    }
    public Builder SetPassport(global::Passport value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasPassport = true;
      result.passport_ = value;
      return this;
    }
    public Builder SetPassport(global::Passport.Builder builderForValue) {
      pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
      PrepareBuilder();
      result.hasPassport = true;
      result.passport_ = builderForValue.Build();
      return this;
    }
    public Builder MergePassport(global::Passport value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      if (result.hasPassport &&
          result.passport_ != global::Passport.DefaultInstance) {
          result.passport_ = global::Passport.CreateBuilder(result.passport_).MergeFrom(value).BuildPartial();
      } else {
        result.passport_ = value;
      }
      result.hasPassport = true;
      return this;
    }
    public Builder ClearPassport() {
      PrepareBuilder();
      result.hasPassport = false;
      result.passport_ = null;
      return this;
    }
    
    public pbc::IPopsicleList<global::PoliceRecord> PoliceRecordsList {
      get { return PrepareBuilder().policeRecords_; }
    }
    public int PoliceRecordsCount {
      get { return result.PoliceRecordsCount; }
    }
    public global::PoliceRecord GetPoliceRecords(int index) {
      return result.GetPoliceRecords(index);
    }
    public Builder SetPoliceRecords(int index, global::PoliceRecord value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.policeRecords_[index] = value;
      return this;
    }
    public Builder SetPoliceRecords(int index, global::PoliceRecord.Builder builderForValue) {
      pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
      PrepareBuilder();
      result.policeRecords_[index] = builderForValue.Build();
      return this;
    }
    public Builder AddPoliceRecords(global::PoliceRecord value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.policeRecords_.Add(value);
      return this;
    }
    public Builder AddPoliceRecords(global::PoliceRecord.Builder builderForValue) {
      pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
      PrepareBuilder();
      result.policeRecords_.Add(builderForValue.Build());
      return this;
    }
    public Builder AddRangePoliceRecords(scg::IEnumerable<global::PoliceRecord> values) {
      PrepareBuilder();
      result.policeRecords_.Add(values);
      return this;
    }
    public Builder ClearPoliceRecords() {
      PrepareBuilder();
      result.policeRecords_.Clear();
      return this;
    }
  }
  static Person() {
    object.ReferenceEquals(global::Proto.Person.Descriptor, null);
  }
}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Node : pb::GeneratedMessage<Node, Node.Builder> {
  private Node() { }
  private static readonly Node defaultInstance = new Node().MakeReadOnly();
  private static readonly string[] _nodeFieldNames = new string[] { "data", "left", "right" };
  private static readonly uint[] _nodeFieldTags = new uint[] { 8, 18, 26 };
  public static Node DefaultInstance {
    get { return defaultInstance; }
  }
  
  public override Node DefaultInstanceForType {
    get { return DefaultInstance; }
  }
  
  protected override Node ThisMessage {
    get { return this; }
  }
  
  public static pbd::MessageDescriptor Descriptor {
    get { return global::Proto.Person.internal__static_Node__Descriptor; }
  }
  
  protected override pb::FieldAccess.FieldAccessorTable<Node, Node.Builder> InternalFieldAccessors {
    get { return global::Proto.Person.internal__static_Node__FieldAccessorTable; }
  }
  
  public const int DataFieldNumber = 1;
  private bool hasData;
  private int data_;
  public bool HasData {
    get { return hasData; }
  }
  public int Data {
    get { return data_; }
  }
  
  public const int LeftFieldNumber = 2;
  private bool hasLeft;
  private global::Node left_;
  public bool HasLeft {
    get { return hasLeft; }
  }
  public global::Node Left {
    get { return left_ ?? global::Node.DefaultInstance; }
  }
  
  public const int RightFieldNumber = 3;
  private bool hasRight;
  private global::Node right_;
  public bool HasRight {
    get { return hasRight; }
  }
  public global::Node Right {
    get { return right_ ?? global::Node.DefaultInstance; }
  }
  
  public override bool IsInitialized {
    get {
      if (!hasData) return false;
      if (HasLeft) {
        if (!Left.IsInitialized) return false;
      }
      if (HasRight) {
        if (!Right.IsInitialized) return false;
      }
      return true;
    }
  }
  
  public override void WriteTo(pb::ICodedOutputStream output) {
    int size = SerializedSize;
    string[] field_names = _nodeFieldNames;
    if (hasData) {
      output.WriteInt32(1, field_names[0], Data);
    }
    if (hasLeft) {
      output.WriteMessage(2, field_names[1], Left);
    }
    if (hasRight) {
      output.WriteMessage(3, field_names[2], Right);
    }
    UnknownFields.WriteTo(output);
  }
  
  private int memoizedSerializedSize = -1;
  public override int SerializedSize {
    get {
      int size = memoizedSerializedSize;
      if (size != -1) return size;
      
      size = 0;
      if (hasData) {
        size += pb::CodedOutputStream.ComputeInt32Size(1, Data);
      }
      if (hasLeft) {
        size += pb::CodedOutputStream.ComputeMessageSize(2, Left);
      }
      if (hasRight) {
        size += pb::CodedOutputStream.ComputeMessageSize(3, Right);
      }
      size += UnknownFields.SerializedSize;
      memoizedSerializedSize = size;
      return size;
    }
  }
  
  public static Node ParseFrom(pb::ByteString data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Node ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Node ParseFrom(byte[] data) {
    return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
  }
  public static Node ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
  }
  public static Node ParseFrom(global::System.IO.Stream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Node ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  public static Node ParseDelimitedFrom(global::System.IO.Stream input) {
    return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
  }
  public static Node ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
    return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
  }
  public static Node ParseFrom(pb::ICodedInputStream input) {
    return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
  }
  public static Node ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
    return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
  }
  private Node MakeReadOnly() {
    return this;
  }
  
  public static Builder CreateBuilder() { return new Builder(); }
  public override Builder ToBuilder() { return CreateBuilder(this); }
  public override Builder CreateBuilderForType() { return new Builder(); }
  public static Builder CreateBuilder(Node prototype) {
    return new Builder(prototype);
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class Builder : pb::GeneratedBuilder<Node, Builder> {
    protected override Builder ThisBuilder {
      get { return this; }
    }
    public Builder() {
      result = DefaultInstance;
      resultIsReadOnly = true;
    }
    internal Builder(Node cloneFrom) {
      result = cloneFrom;
      resultIsReadOnly = true;
    }
    
    private bool resultIsReadOnly;
    private Node result;
    
    private Node PrepareBuilder() {
      if (resultIsReadOnly) {
        Node original = result;
        result = new Node();
        resultIsReadOnly = false;
        MergeFrom(original);
      }
      return result;
    }
    
    public override bool IsInitialized {
      get { return result.IsInitialized; }
    }
    
    protected override Node MessageBeingBuilt {
      get { return PrepareBuilder(); }
    }
    
    public override Builder Clear() {
      result = DefaultInstance;
      resultIsReadOnly = true;
      return this;
    }
    
    public override Builder Clone() {
      if (resultIsReadOnly) {
        return new Builder(result);
      } else {
        return new Builder().MergeFrom(result);
      }
    }
    
    public override pbd::MessageDescriptor DescriptorForType {
      get { return global::Node.Descriptor; }
    }
    
    public override Node DefaultInstanceForType {
      get { return global::Node.DefaultInstance; }
    }
    
    public override Node BuildPartial() {
      if (resultIsReadOnly) {
        return result;
      }
      resultIsReadOnly = true;
      return result.MakeReadOnly();
    }
    
    public override Builder MergeFrom(pb::IMessage other) {
      if (other is Node) {
        return MergeFrom((Node) other);
      } else {
        base.MergeFrom(other);
        return this;
      }
    }
    
    public override Builder MergeFrom(Node other) {
      if (other == global::Node.DefaultInstance) return this;
      PrepareBuilder();
      if (other.HasData) {
        Data = other.Data;
      }
      if (other.HasLeft) {
        MergeLeft(other.Left);
      }
      if (other.HasRight) {
        MergeRight(other.Right);
      }
      this.MergeUnknownFields(other.UnknownFields);
      return this;
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input) {
      return MergeFrom(input, pb::ExtensionRegistry.Empty);
    }
    
    public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      PrepareBuilder();
      pb::UnknownFieldSet.Builder unknownFields = null;
      uint tag;
      string field_name;
      while (input.ReadTag(out tag, out field_name)) {
        if(tag == 0 && field_name != null) {
          int field_ordinal = global::System.Array.BinarySearch(_nodeFieldNames, field_name, global::System.StringComparer.Ordinal);
          if(field_ordinal >= 0)
            tag = _nodeFieldTags[field_ordinal];
          else {
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            continue;
          }
        }
        switch (tag) {
          case 0: {
            throw pb::InvalidProtocolBufferException.InvalidTag();
          }
          default: {
            if (pb::WireFormat.IsEndGroupTag(tag)) {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            if (unknownFields == null) {
              unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            }
            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
            break;
          }
          case 8: {
            result.hasData = input.ReadInt32(ref result.data_);
            break;
          }
          case 18: {
            global::Node.Builder subBuilder = global::Node.CreateBuilder();
            if (result.hasLeft) {
              subBuilder.MergeFrom(Left);
            }
            input.ReadMessage(subBuilder, extensionRegistry);
            Left = subBuilder.BuildPartial();
            break;
          }
          case 26: {
            global::Node.Builder subBuilder = global::Node.CreateBuilder();
            if (result.hasRight) {
              subBuilder.MergeFrom(Right);
            }
            input.ReadMessage(subBuilder, extensionRegistry);
            Right = subBuilder.BuildPartial();
            break;
          }
        }
      }
      
      if (unknownFields != null) {
        this.UnknownFields = unknownFields.Build();
      }
      return this;
    }
    
    
    public bool HasData {
      get { return result.hasData; }
    }
    public int Data {
      get { return result.Data; }
      set { SetData(value); }
    }
    public Builder SetData(int value) {
      PrepareBuilder();
      result.hasData = true;
      result.data_ = value;
      return this;
    }
    public Builder ClearData() {
      PrepareBuilder();
      result.hasData = false;
      result.data_ = 0;
      return this;
    }
    
    public bool HasLeft {
     get { return result.hasLeft; }
    }
    public global::Node Left {
      get { return result.Left; }
      set { SetLeft(value); }
    }
    public Builder SetLeft(global::Node value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasLeft = true;
      result.left_ = value;
      return this;
    }
    public Builder SetLeft(global::Node.Builder builderForValue) {
      pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
      PrepareBuilder();
      result.hasLeft = true;
      result.left_ = builderForValue.Build();
      return this;
    }
    public Builder MergeLeft(global::Node value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      if (result.hasLeft &&
          result.left_ != global::Node.DefaultInstance) {
          result.left_ = global::Node.CreateBuilder(result.left_).MergeFrom(value).BuildPartial();
      } else {
        result.left_ = value;
      }
      result.hasLeft = true;
      return this;
    }
    public Builder ClearLeft() {
      PrepareBuilder();
      result.hasLeft = false;
      result.left_ = null;
      return this;
    }
    
    public bool HasRight {
     get { return result.hasRight; }
    }
    public global::Node Right {
      get { return result.Right; }
      set { SetRight(value); }
    }
    public Builder SetRight(global::Node value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      result.hasRight = true;
      result.right_ = value;
      return this;
    }
    public Builder SetRight(global::Node.Builder builderForValue) {
      pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
      PrepareBuilder();
      result.hasRight = true;
      result.right_ = builderForValue.Build();
      return this;
    }
    public Builder MergeRight(global::Node value) {
      pb::ThrowHelper.ThrowIfNull(value, "value");
      PrepareBuilder();
      if (result.hasRight &&
          result.right_ != global::Node.DefaultInstance) {
          result.right_ = global::Node.CreateBuilder(result.right_).MergeFrom(value).BuildPartial();
      } else {
        result.right_ = value;
      }
      result.hasRight = true;
      return this;
    }
    public Builder ClearRight() {
      PrepareBuilder();
      result.hasRight = false;
      result.right_ = null;
      return this;
    }
  }
  static Node() {
    object.ReferenceEquals(global::Proto.Person.Descriptor, null);
  }
}

#endregion


#endregion Designer generated code