src/csharp/Grpc.Examples/Math.cs - third_party/grpc - Git at Google

 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 // source: math/math.proto
 #pragma warning disable 1591, 0612, 3021
 #region Designer generated code

 using pb = global::Google.Protobuf;
 using pbc = global::Google.Protobuf.Collections;
 using pbr = global::Google.Protobuf.Reflection;
 using scg = global::System.Collections.Generic;
 namespace Math {

   /// <summary>Holder for reflection information generated from math/math.proto</summary>
   public static partial class MathReflection {

     #region Descriptor
     /// <summary>File descriptor for math/math.proto</summary>
     public static pbr::FileDescriptor Descriptor {
       get { return descriptor; }
     }
     private static pbr::FileDescriptor descriptor;

     static MathReflection() {
       byte[] descriptorData = global::System.Convert.FromBase64String(
           string.Concat(
             "Cg9tYXRoL21hdGgucHJvdG8SBG1hdGgiLAoHRGl2QXJncxIQCghkaXZpZGVu",
             "ZBgBIAEoAxIPCgdkaXZpc29yGAIgASgDIi8KCERpdlJlcGx5EhAKCHF1b3Rp",
             "ZW50GAEgASgDEhEKCXJlbWFpbmRlchgCIAEoAyIYCgdGaWJBcmdzEg0KBWxp",
             "bWl0GAEgASgDIhIKA051bRILCgNudW0YASABKAMiGQoIRmliUmVwbHkSDQoF",
             "Y291bnQYASABKAMypAEKBE1hdGgSJgoDRGl2Eg0ubWF0aC5EaXZBcmdzGg4u",
             "bWF0aC5EaXZSZXBseSIAEi4KB0Rpdk1hbnkSDS5tYXRoLkRpdkFyZ3MaDi5t",
             "YXRoLkRpdlJlcGx5IgAoATABEiMKA0ZpYhINLm1hdGguRmliQXJncxoJLm1h",
             "dGguTnVtIgAwARIfCgNTdW0SCS5tYXRoLk51bRoJLm1hdGguTnVtIgAoAWIG",
             "cHJvdG8z"));
       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
           new pbr::FileDescriptor[] { },
           new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
             new pbr::GeneratedClrTypeInfo(typeof(global::Math.DivArgs), global::Math.DivArgs.Parser, new[]{ "Dividend", "Divisor" }, null, null, null),
             new pbr::GeneratedClrTypeInfo(typeof(global::Math.DivReply), global::Math.DivReply.Parser, new[]{ "Quotient", "Remainder" }, null, null, null),
             new pbr::GeneratedClrTypeInfo(typeof(global::Math.FibArgs), global::Math.FibArgs.Parser, new[]{ "Limit" }, null, null, null),
             new pbr::GeneratedClrTypeInfo(typeof(global::Math.Num), global::Math.Num.Parser, new[]{ "Num_" }, null, null, null),
             new pbr::GeneratedClrTypeInfo(typeof(global::Math.FibReply), global::Math.FibReply.Parser, new[]{ "Count" }, null, null, null)
           }));
     }
     #endregion

   }
   #region Messages
   public sealed partial class DivArgs : pb::IMessage<DivArgs> {
     private static readonly pb::MessageParser<DivArgs> _parser = new pb::MessageParser<DivArgs>(() => new DivArgs());
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pb::MessageParser<DivArgs> Parser { get { return _parser; } }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pbr::MessageDescriptor Descriptor {
       get { return global::Math.MathReflection.Descriptor.MessageTypes[0]; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     pbr::MessageDescriptor pb::IMessage.Descriptor {
       get { return Descriptor; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivArgs() {
       OnConstruction();
     }

     partial void OnConstruction();

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivArgs(DivArgs other) : this() {
       dividend_ = other.dividend_;
       divisor_ = other.divisor_;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivArgs Clone() {
       return new DivArgs(this);
     }

     /// <summary>Field number for the "dividend" field.</summary>
     public const int DividendFieldNumber = 1;
     private long dividend_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Dividend {
       get { return dividend_; }
       set {
         dividend_ = value;
       }
     }

     /// <summary>Field number for the "divisor" field.</summary>
     public const int DivisorFieldNumber = 2;
     private long divisor_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Divisor {
       get { return divisor_; }
       set {
         divisor_ = value;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as DivArgs);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public bool Equals(DivArgs other) {
       if (ReferenceEquals(other, null)) {
         return false;
       }
       if (ReferenceEquals(other, this)) {
         return true;
       }
       if (Dividend != other.Dividend) return false;
       if (Divisor != other.Divisor) return false;
       return true;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override int GetHashCode() {
       int hash = 1;
       if (Dividend != 0L) hash ^= Dividend.GetHashCode();
       if (Divisor != 0L) hash ^= Divisor.GetHashCode();
       return hash;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override string ToString() {
       return pb::JsonFormatter.ToDiagnosticString(this);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       if (Dividend != 0L) {
         output.WriteRawTag(8);
         output.WriteInt64(Dividend);
       }
       if (Divisor != 0L) {
         output.WriteRawTag(16);
         output.WriteInt64(Divisor);
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int CalculateSize() {
       int size = 0;
       if (Dividend != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Dividend);
       }
       if (Divisor != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Divisor);
       }
       return size;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(DivArgs other) {
       if (other == null) {
         return;
       }
       if (other.Dividend != 0L) {
         Dividend = other.Dividend;
       }
       if (other.Divisor != 0L) {
         Divisor = other.Divisor;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
       while ((tag = input.ReadTag()) != 0) {
         switch(tag) {
           default:
             input.SkipLastField();
             break;
           case 8: {
             Dividend = input.ReadInt64();
             break;
           }
           case 16: {
             Divisor = input.ReadInt64();
             break;
           }
         }
       }
     }

   }

   public sealed partial class DivReply : pb::IMessage<DivReply> {
     private static readonly pb::MessageParser<DivReply> _parser = new pb::MessageParser<DivReply>(() => new DivReply());
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pb::MessageParser<DivReply> Parser { get { return _parser; } }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pbr::MessageDescriptor Descriptor {
       get { return global::Math.MathReflection.Descriptor.MessageTypes[1]; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     pbr::MessageDescriptor pb::IMessage.Descriptor {
       get { return Descriptor; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivReply() {
       OnConstruction();
     }

     partial void OnConstruction();

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivReply(DivReply other) : this() {
       quotient_ = other.quotient_;
       remainder_ = other.remainder_;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public DivReply Clone() {
       return new DivReply(this);
     }

     /// <summary>Field number for the "quotient" field.</summary>
     public const int QuotientFieldNumber = 1;
     private long quotient_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Quotient {
       get { return quotient_; }
       set {
         quotient_ = value;
       }
     }

     /// <summary>Field number for the "remainder" field.</summary>
     public const int RemainderFieldNumber = 2;
     private long remainder_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Remainder {
       get { return remainder_; }
       set {
         remainder_ = value;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as DivReply);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public bool Equals(DivReply other) {
       if (ReferenceEquals(other, null)) {
         return false;
       }
       if (ReferenceEquals(other, this)) {
         return true;
       }
       if (Quotient != other.Quotient) return false;
       if (Remainder != other.Remainder) return false;
       return true;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override int GetHashCode() {
       int hash = 1;
       if (Quotient != 0L) hash ^= Quotient.GetHashCode();
       if (Remainder != 0L) hash ^= Remainder.GetHashCode();
       return hash;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override string ToString() {
       return pb::JsonFormatter.ToDiagnosticString(this);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       if (Quotient != 0L) {
         output.WriteRawTag(8);
         output.WriteInt64(Quotient);
       }
       if (Remainder != 0L) {
         output.WriteRawTag(16);
         output.WriteInt64(Remainder);
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int CalculateSize() {
       int size = 0;
       if (Quotient != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Quotient);
       }
       if (Remainder != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Remainder);
       }
       return size;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(DivReply other) {
       if (other == null) {
         return;
       }
       if (other.Quotient != 0L) {
         Quotient = other.Quotient;
       }
       if (other.Remainder != 0L) {
         Remainder = other.Remainder;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
       while ((tag = input.ReadTag()) != 0) {
         switch(tag) {
           default:
             input.SkipLastField();
             break;
           case 8: {
             Quotient = input.ReadInt64();
             break;
           }
           case 16: {
             Remainder = input.ReadInt64();
             break;
           }
         }
       }
     }

   }

   public sealed partial class FibArgs : pb::IMessage<FibArgs> {
     private static readonly pb::MessageParser<FibArgs> _parser = new pb::MessageParser<FibArgs>(() => new FibArgs());
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pb::MessageParser<FibArgs> Parser { get { return _parser; } }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pbr::MessageDescriptor Descriptor {
       get { return global::Math.MathReflection.Descriptor.MessageTypes[2]; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     pbr::MessageDescriptor pb::IMessage.Descriptor {
       get { return Descriptor; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibArgs() {
       OnConstruction();
     }

     partial void OnConstruction();

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibArgs(FibArgs other) : this() {
       limit_ = other.limit_;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibArgs Clone() {
       return new FibArgs(this);
     }

     /// <summary>Field number for the "limit" field.</summary>
     public const int LimitFieldNumber = 1;
     private long limit_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Limit {
       get { return limit_; }
       set {
         limit_ = value;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as FibArgs);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public bool Equals(FibArgs other) {
       if (ReferenceEquals(other, null)) {
         return false;
       }
       if (ReferenceEquals(other, this)) {
         return true;
       }
       if (Limit != other.Limit) return false;
       return true;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override int GetHashCode() {
       int hash = 1;
       if (Limit != 0L) hash ^= Limit.GetHashCode();
       return hash;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override string ToString() {
       return pb::JsonFormatter.ToDiagnosticString(this);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       if (Limit != 0L) {
         output.WriteRawTag(8);
         output.WriteInt64(Limit);
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int CalculateSize() {
       int size = 0;
       if (Limit != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Limit);
       }
       return size;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(FibArgs other) {
       if (other == null) {
         return;
       }
       if (other.Limit != 0L) {
         Limit = other.Limit;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
       while ((tag = input.ReadTag()) != 0) {
         switch(tag) {
           default:
             input.SkipLastField();
             break;
           case 8: {
             Limit = input.ReadInt64();
             break;
           }
         }
       }
     }

   }

   public sealed partial class Num : pb::IMessage<Num> {
     private static readonly pb::MessageParser<Num> _parser = new pb::MessageParser<Num>(() => new Num());
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pb::MessageParser<Num> Parser { get { return _parser; } }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pbr::MessageDescriptor Descriptor {
       get { return global::Math.MathReflection.Descriptor.MessageTypes[3]; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     pbr::MessageDescriptor pb::IMessage.Descriptor {
       get { return Descriptor; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public Num() {
       OnConstruction();
     }

     partial void OnConstruction();

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public Num(Num other) : this() {
       num_ = other.num_;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public Num Clone() {
       return new Num(this);
     }

     /// <summary>Field number for the "num" field.</summary>
     public const int Num_FieldNumber = 1;
     private long num_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Num_ {
       get { return num_; }
       set {
         num_ = value;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as Num);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public bool Equals(Num other) {
       if (ReferenceEquals(other, null)) {
         return false;
       }
       if (ReferenceEquals(other, this)) {
         return true;
       }
       if (Num_ != other.Num_) return false;
       return true;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override int GetHashCode() {
       int hash = 1;
       if (Num_ != 0L) hash ^= Num_.GetHashCode();
       return hash;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override string ToString() {
       return pb::JsonFormatter.ToDiagnosticString(this);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       if (Num_ != 0L) {
         output.WriteRawTag(8);
         output.WriteInt64(Num_);
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int CalculateSize() {
       int size = 0;
       if (Num_ != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Num_);
       }
       return size;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(Num other) {
       if (other == null) {
         return;
       }
       if (other.Num_ != 0L) {
         Num_ = other.Num_;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
       while ((tag = input.ReadTag()) != 0) {
         switch(tag) {
           default:
             input.SkipLastField();
             break;
           case 8: {
             Num_ = input.ReadInt64();
             break;
           }
         }
       }
     }

   }

   public sealed partial class FibReply : pb::IMessage<FibReply> {
     private static readonly pb::MessageParser<FibReply> _parser = new pb::MessageParser<FibReply>(() => new FibReply());
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pb::MessageParser<FibReply> Parser { get { return _parser; } }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public static pbr::MessageDescriptor Descriptor {
       get { return global::Math.MathReflection.Descriptor.MessageTypes[4]; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     pbr::MessageDescriptor pb::IMessage.Descriptor {
       get { return Descriptor; }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibReply() {
       OnConstruction();
     }

     partial void OnConstruction();

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibReply(FibReply other) : this() {
       count_ = other.count_;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public FibReply Clone() {
       return new FibReply(this);
     }

     /// <summary>Field number for the "count" field.</summary>
     public const int CountFieldNumber = 1;
     private long count_;
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public long Count {
       get { return count_; }
       set {
         count_ = value;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override bool Equals(object other) {
       return Equals(other as FibReply);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public bool Equals(FibReply other) {
       if (ReferenceEquals(other, null)) {
         return false;
       }
       if (ReferenceEquals(other, this)) {
         return true;
       }
       if (Count != other.Count) return false;
       return true;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override int GetHashCode() {
       int hash = 1;
       if (Count != 0L) hash ^= Count.GetHashCode();
       return hash;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public override string ToString() {
       return pb::JsonFormatter.ToDiagnosticString(this);
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void WriteTo(pb::CodedOutputStream output) {
       if (Count != 0L) {
         output.WriteRawTag(8);
         output.WriteInt64(Count);
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public int CalculateSize() {
       int size = 0;
       if (Count != 0L) {
         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Count);
       }
       return size;
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(FibReply other) {
       if (other == null) {
         return;
       }
       if (other.Count != 0L) {
         Count = other.Count;
       }
     }

     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
     public void MergeFrom(pb::CodedInputStream input) {
       uint tag;
       while ((tag = input.ReadTag()) != 0) {
         switch(tag) {
           default:
             input.SkipLastField();
             break;
           case 8: {
             Count = input.ReadInt64();
             break;
           }
         }
       }
     }

   }

   #endregion

 }

 #endregion Designer generated code
	// Generated by the protocol buffer compiler. DO NOT EDIT!
	// source: math/math.proto
	#pragma warning disable 1591, 0612, 3021
	#region Designer generated code

	using pb = global::Google.Protobuf;
	using pbc = global::Google.Protobuf.Collections;
	using pbr = global::Google.Protobuf.Reflection;
	using scg = global::System.Collections.Generic;
	namespace Math {

	/// <summary>Holder for reflection information generated from math/math.proto</summary>
	public static partial class MathReflection {

	#region Descriptor
	/// <summary>File descriptor for math/math.proto</summary>
	public static pbr::FileDescriptor Descriptor {
	get { return descriptor; }
	}
	private static pbr::FileDescriptor descriptor;

	static MathReflection() {
	byte[] descriptorData = global::System.Convert.FromBase64String(
	string.Concat(
	"Cg9tYXRoL21hdGgucHJvdG8SBG1hdGgiLAoHRGl2QXJncxIQCghkaXZpZGVu",
	"ZBgBIAEoAxIPCgdkaXZpc29yGAIgASgDIi8KCERpdlJlcGx5EhAKCHF1b3Rp",
	"ZW50GAEgASgDEhEKCXJlbWFpbmRlchgCIAEoAyIYCgdGaWJBcmdzEg0KBWxp",
	"bWl0GAEgASgDIhIKA051bRILCgNudW0YASABKAMiGQoIRmliUmVwbHkSDQoF",
	"Y291bnQYASABKAMypAEKBE1hdGgSJgoDRGl2Eg0ubWF0aC5EaXZBcmdzGg4u",
	"bWF0aC5EaXZSZXBseSIAEi4KB0Rpdk1hbnkSDS5tYXRoLkRpdkFyZ3MaDi5t",
	"YXRoLkRpdlJlcGx5IgAoATABEiMKA0ZpYhINLm1hdGguRmliQXJncxoJLm1h",
	"dGguTnVtIgAwARIfCgNTdW0SCS5tYXRoLk51bRoJLm1hdGguTnVtIgAoAWIG",
	"cHJvdG8z"));
	descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
	new pbr::FileDescriptor[] { },
	new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
	new pbr::GeneratedClrTypeInfo(typeof(global::Math.DivArgs), global::Math.DivArgs.Parser, new[]{ "Dividend", "Divisor" }, null, null, null),
	new pbr::GeneratedClrTypeInfo(typeof(global::Math.DivReply), global::Math.DivReply.Parser, new[]{ "Quotient", "Remainder" }, null, null, null),
	new pbr::GeneratedClrTypeInfo(typeof(global::Math.FibArgs), global::Math.FibArgs.Parser, new[]{ "Limit" }, null, null, null),
	new pbr::GeneratedClrTypeInfo(typeof(global::Math.Num), global::Math.Num.Parser, new[]{ "Num_" }, null, null, null),
	new pbr::GeneratedClrTypeInfo(typeof(global::Math.FibReply), global::Math.FibReply.Parser, new[]{ "Count" }, null, null, null)
	}));
	}
	#endregion

	}
	#region Messages
	public sealed partial class DivArgs : pb::IMessage<DivArgs> {
	private static readonly pb::MessageParser<DivArgs> _parser = new pb::MessageParser<DivArgs>(() => new DivArgs());
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pb::MessageParser<DivArgs> Parser { get { return _parser; } }

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pbr::MessageDescriptor Descriptor {
	get { return global::Math.MathReflection.Descriptor.MessageTypes[0]; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	pbr::MessageDescriptor pb::IMessage.Descriptor {
	get { return Descriptor; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivArgs() {
	OnConstruction();
	}

	partial void OnConstruction();

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivArgs(DivArgs other) : this() {
	dividend_ = other.dividend_;
	divisor_ = other.divisor_;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivArgs Clone() {
	return new DivArgs(this);
	}

	/// <summary>Field number for the "dividend" field.</summary>
	public const int DividendFieldNumber = 1;
	private long dividend_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Dividend {
	get { return dividend_; }
	set {
	dividend_ = value;
	}
	}

	/// <summary>Field number for the "divisor" field.</summary>
	public const int DivisorFieldNumber = 2;
	private long divisor_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Divisor {
	get { return divisor_; }
	set {
	divisor_ = value;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override bool Equals(object other) {
	return Equals(other as DivArgs);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public bool Equals(DivArgs other) {
	if (ReferenceEquals(other, null)) {
	return false;
	}
	if (ReferenceEquals(other, this)) {
	return true;
	}
	if (Dividend != other.Dividend) return false;
	if (Divisor != other.Divisor) return false;
	return true;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override int GetHashCode() {
	int hash = 1;
	if (Dividend != 0L) hash ^= Dividend.GetHashCode();
	if (Divisor != 0L) hash ^= Divisor.GetHashCode();
	return hash;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override string ToString() {
	return pb::JsonFormatter.ToDiagnosticString(this);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void WriteTo(pb::CodedOutputStream output) {
	if (Dividend != 0L) {
	output.WriteRawTag(8);
	output.WriteInt64(Dividend);
	}
	if (Divisor != 0L) {
	output.WriteRawTag(16);
	output.WriteInt64(Divisor);
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public int CalculateSize() {
	int size = 0;
	if (Dividend != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Dividend);
	}
	if (Divisor != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Divisor);
	}
	return size;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(DivArgs other) {
	if (other == null) {
	return;
	}
	if (other.Dividend != 0L) {
	Dividend = other.Dividend;
	}
	if (other.Divisor != 0L) {
	Divisor = other.Divisor;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(pb::CodedInputStream input) {
	uint tag;
	while ((tag = input.ReadTag()) != 0) {
	switch(tag) {
	default:
	input.SkipLastField();
	break;
	case 8: {
	Dividend = input.ReadInt64();
	break;
	}
	case 16: {
	Divisor = input.ReadInt64();
	break;
	}
	}
	}
	}

	}

	public sealed partial class DivReply : pb::IMessage<DivReply> {
	private static readonly pb::MessageParser<DivReply> _parser = new pb::MessageParser<DivReply>(() => new DivReply());
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pb::MessageParser<DivReply> Parser { get { return _parser; } }

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pbr::MessageDescriptor Descriptor {
	get { return global::Math.MathReflection.Descriptor.MessageTypes[1]; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	pbr::MessageDescriptor pb::IMessage.Descriptor {
	get { return Descriptor; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivReply() {
	OnConstruction();
	}

	partial void OnConstruction();

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivReply(DivReply other) : this() {
	quotient_ = other.quotient_;
	remainder_ = other.remainder_;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public DivReply Clone() {
	return new DivReply(this);
	}

	/// <summary>Field number for the "quotient" field.</summary>
	public const int QuotientFieldNumber = 1;
	private long quotient_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Quotient {
	get { return quotient_; }
	set {
	quotient_ = value;
	}
	}

	/// <summary>Field number for the "remainder" field.</summary>
	public const int RemainderFieldNumber = 2;
	private long remainder_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Remainder {
	get { return remainder_; }
	set {
	remainder_ = value;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override bool Equals(object other) {
	return Equals(other as DivReply);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public bool Equals(DivReply other) {
	if (ReferenceEquals(other, null)) {
	return false;
	}
	if (ReferenceEquals(other, this)) {
	return true;
	}
	if (Quotient != other.Quotient) return false;
	if (Remainder != other.Remainder) return false;
	return true;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override int GetHashCode() {
	int hash = 1;
	if (Quotient != 0L) hash ^= Quotient.GetHashCode();
	if (Remainder != 0L) hash ^= Remainder.GetHashCode();
	return hash;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override string ToString() {
	return pb::JsonFormatter.ToDiagnosticString(this);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void WriteTo(pb::CodedOutputStream output) {
	if (Quotient != 0L) {
	output.WriteRawTag(8);
	output.WriteInt64(Quotient);
	}
	if (Remainder != 0L) {
	output.WriteRawTag(16);
	output.WriteInt64(Remainder);
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public int CalculateSize() {
	int size = 0;
	if (Quotient != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Quotient);
	}
	if (Remainder != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Remainder);
	}
	return size;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(DivReply other) {
	if (other == null) {
	return;
	}
	if (other.Quotient != 0L) {
	Quotient = other.Quotient;
	}
	if (other.Remainder != 0L) {
	Remainder = other.Remainder;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(pb::CodedInputStream input) {
	uint tag;
	while ((tag = input.ReadTag()) != 0) {
	switch(tag) {
	default:
	input.SkipLastField();
	break;
	case 8: {
	Quotient = input.ReadInt64();
	break;
	}
	case 16: {
	Remainder = input.ReadInt64();
	break;
	}
	}
	}
	}

	}

	public sealed partial class FibArgs : pb::IMessage<FibArgs> {
	private static readonly pb::MessageParser<FibArgs> _parser = new pb::MessageParser<FibArgs>(() => new FibArgs());
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pb::MessageParser<FibArgs> Parser { get { return _parser; } }

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pbr::MessageDescriptor Descriptor {
	get { return global::Math.MathReflection.Descriptor.MessageTypes[2]; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	pbr::MessageDescriptor pb::IMessage.Descriptor {
	get { return Descriptor; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibArgs() {
	OnConstruction();
	}

	partial void OnConstruction();

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibArgs(FibArgs other) : this() {
	limit_ = other.limit_;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibArgs Clone() {
	return new FibArgs(this);
	}

	/// <summary>Field number for the "limit" field.</summary>
	public const int LimitFieldNumber = 1;
	private long limit_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Limit {
	get { return limit_; }
	set {
	limit_ = value;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override bool Equals(object other) {
	return Equals(other as FibArgs);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public bool Equals(FibArgs other) {
	if (ReferenceEquals(other, null)) {
	return false;
	}
	if (ReferenceEquals(other, this)) {
	return true;
	}
	if (Limit != other.Limit) return false;
	return true;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override int GetHashCode() {
	int hash = 1;
	if (Limit != 0L) hash ^= Limit.GetHashCode();
	return hash;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override string ToString() {
	return pb::JsonFormatter.ToDiagnosticString(this);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void WriteTo(pb::CodedOutputStream output) {
	if (Limit != 0L) {
	output.WriteRawTag(8);
	output.WriteInt64(Limit);
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public int CalculateSize() {
	int size = 0;
	if (Limit != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Limit);
	}
	return size;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(FibArgs other) {
	if (other == null) {
	return;
	}
	if (other.Limit != 0L) {
	Limit = other.Limit;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(pb::CodedInputStream input) {
	uint tag;
	while ((tag = input.ReadTag()) != 0) {
	switch(tag) {
	default:
	input.SkipLastField();
	break;
	case 8: {
	Limit = input.ReadInt64();
	break;
	}
	}
	}
	}

	}

	public sealed partial class Num : pb::IMessage<Num> {
	private static readonly pb::MessageParser<Num> _parser = new pb::MessageParser<Num>(() => new Num());
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pb::MessageParser<Num> Parser { get { return _parser; } }

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pbr::MessageDescriptor Descriptor {
	get { return global::Math.MathReflection.Descriptor.MessageTypes[3]; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	pbr::MessageDescriptor pb::IMessage.Descriptor {
	get { return Descriptor; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public Num() {
	OnConstruction();
	}

	partial void OnConstruction();

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public Num(Num other) : this() {
	num_ = other.num_;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public Num Clone() {
	return new Num(this);
	}

	/// <summary>Field number for the "num" field.</summary>
	public const int Num_FieldNumber = 1;
	private long num_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Num_ {
	get { return num_; }
	set {
	num_ = value;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override bool Equals(object other) {
	return Equals(other as Num);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public bool Equals(Num other) {
	if (ReferenceEquals(other, null)) {
	return false;
	}
	if (ReferenceEquals(other, this)) {
	return true;
	}
	if (Num_ != other.Num_) return false;
	return true;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override int GetHashCode() {
	int hash = 1;
	if (Num_ != 0L) hash ^= Num_.GetHashCode();
	return hash;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override string ToString() {
	return pb::JsonFormatter.ToDiagnosticString(this);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void WriteTo(pb::CodedOutputStream output) {
	if (Num_ != 0L) {
	output.WriteRawTag(8);
	output.WriteInt64(Num_);
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public int CalculateSize() {
	int size = 0;
	if (Num_ != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Num_);
	}
	return size;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(Num other) {
	if (other == null) {
	return;
	}
	if (other.Num_ != 0L) {
	Num_ = other.Num_;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(pb::CodedInputStream input) {
	uint tag;
	while ((tag = input.ReadTag()) != 0) {
	switch(tag) {
	default:
	input.SkipLastField();
	break;
	case 8: {
	Num_ = input.ReadInt64();
	break;
	}
	}
	}
	}

	}

	public sealed partial class FibReply : pb::IMessage<FibReply> {
	private static readonly pb::MessageParser<FibReply> _parser = new pb::MessageParser<FibReply>(() => new FibReply());
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pb::MessageParser<FibReply> Parser { get { return _parser; } }

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public static pbr::MessageDescriptor Descriptor {
	get { return global::Math.MathReflection.Descriptor.MessageTypes[4]; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	pbr::MessageDescriptor pb::IMessage.Descriptor {
	get { return Descriptor; }
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibReply() {
	OnConstruction();
	}

	partial void OnConstruction();

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibReply(FibReply other) : this() {
	count_ = other.count_;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public FibReply Clone() {
	return new FibReply(this);
	}

	/// <summary>Field number for the "count" field.</summary>
	public const int CountFieldNumber = 1;
	private long count_;
	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public long Count {
	get { return count_; }
	set {
	count_ = value;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override bool Equals(object other) {
	return Equals(other as FibReply);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public bool Equals(FibReply other) {
	if (ReferenceEquals(other, null)) {
	return false;
	}
	if (ReferenceEquals(other, this)) {
	return true;
	}
	if (Count != other.Count) return false;
	return true;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override int GetHashCode() {
	int hash = 1;
	if (Count != 0L) hash ^= Count.GetHashCode();
	return hash;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public override string ToString() {
	return pb::JsonFormatter.ToDiagnosticString(this);
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void WriteTo(pb::CodedOutputStream output) {
	if (Count != 0L) {
	output.WriteRawTag(8);
	output.WriteInt64(Count);
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public int CalculateSize() {
	int size = 0;
	if (Count != 0L) {
	size += 1 + pb::CodedOutputStream.ComputeInt64Size(Count);
	}
	return size;
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(FibReply other) {
	if (other == null) {
	return;
	}
	if (other.Count != 0L) {
	Count = other.Count;
	}
	}

	[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
	public void MergeFrom(pb::CodedInputStream input) {
	uint tag;
	while ((tag = input.ReadTag()) != 0) {
	switch(tag) {
	default:
	input.SkipLastField();
	break;
	case 8: {
	Count = input.ReadInt64();
	break;
	}
	}
	}
	}

	}

	#endregion

	}

	#endregion Designer generated code