using System;
using System.Buffers;
using System.Buffers.Binary;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Google.Protobuf.Collections;
using Google.Protobuf.Reflection;
using Google.Protobuf.WellKnownTypes;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: InternalsVisibleTo("Google.Protobuf.Test, PublicKey=002400000480000094000000060200000024000052534131000400000100010025800fbcfc63a17c66b303aae80b03a6beaa176bb6bef883be436f2a1579edd80ce23edf151a1f4ced97af83abcd981207041fd5b2da3b498346fcfcd94910d52f25537c4a43ce3fbe17dc7d43e6cbdb4d8f1242dcb6bd9b5906be74da8daa7d7280f97130f318a16c07baf118839b156299a48522f9fae2371c9665c5ae9cb6")]
[assembly: InternalsVisibleTo("Google.Protobuf.Benchmarks, PublicKey=002400000480000094000000060200000024000052534131000400000100010025800fbcfc63a17c66b303aae80b03a6beaa176bb6bef883be436f2a1579edd80ce23edf151a1f4ced97af83abcd981207041fd5b2da3b498346fcfcd94910d52f25537c4a43ce3fbe17dc7d43e6cbdb4d8f1242dcb6bd9b5906be74da8daa7d7280f97130f318a16c07baf118839b156299a48522f9fae2371c9665c5ae9cb6")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: AssemblyCompany("Google Inc.")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2015, Google Inc.")]
[assembly: AssemblyDescription("C# runtime library for Protocol Buffers - Google's data interchange format.")]
[assembly: AssemblyFileVersion("3.21.9.0")]
[assembly: AssemblyInformationalVersion("3.21.9+d96db0e9d8ef9e9c754ee1ffac58654969f3b662")]
[assembly: AssemblyProduct("Google.Protobuf")]
[assembly: AssemblyTitle("Google Protocol Buffers")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/protocolbuffers/protobuf.git")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.21.9.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	internal sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[Flags]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		Interfaces = 0x2000,
		All = -1
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
	internal sealed class RequiresUnreferencedCodeAttribute : Attribute
	{
		public string Message { get; }

		public string Url { get; set; }

		public RequiresUnreferencedCodeAttribute(string message)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
	internal sealed class UnconditionalSuppressMessageAttribute : Attribute
	{
		public string Category { get; }

		public string CheckId { get; }

		public string Scope { get; set; }

		public string Target { get; set; }

		public string MessageId { get; set; }

		public string Justification { get; set; }

		public UnconditionalSuppressMessageAttribute(string category, string checkId)
		{
			Category = category;
			CheckId = checkId;
		}
	}
}
namespace Google.Protobuf
{
	internal static class ByteArray
	{
		private const int CopyThreshold = 12;

		internal static void Copy(byte[] src, int srcOffset, byte[] dst, int dstOffset, int count)
		{
			if (count > 12)
			{
				Buffer.BlockCopy(src, srcOffset, dst, dstOffset, count);
				return;
			}
			int num = srcOffset + count;
			for (int i = srcOffset; i < num; i++)
			{
				dst[dstOffset++] = src[i];
			}
		}

		internal static void Reverse(byte[] bytes)
		{
			int num = 0;
			int num2 = bytes.Length - 1;
			while (num < num2)
			{
				byte b = bytes[num];
				bytes[num] = bytes[num2];
				bytes[num2] = b;
				num++;
				num2--;
			}
		}
	}
	[SecuritySafeCritical]
	public sealed class ByteString : IEnumerable<byte>, IEnumerable, IEquatable<ByteString>
	{
		private static readonly ByteString empty = new ByteString(new byte[0]);

		private readonly ReadOnlyMemory<byte> bytes;

		public static ByteString Empty => empty;

		public int Length => bytes.Length;

		public bool IsEmpty => Length == 0;

		public ReadOnlySpan<byte> Span => bytes.Span;

		public ReadOnlyMemory<byte> Memory => bytes;

		public byte this[int index] => bytes.Span[index];

		internal static ByteString AttachBytes(ReadOnlyMemory<byte> bytes)
		{
			return new ByteString(bytes);
		}

		internal static ByteString AttachBytes(byte[] bytes)
		{
			return AttachBytes(bytes.AsMemory());
		}

		private ByteString(ReadOnlyMemory<byte> bytes)
		{
			this.bytes = bytes;
		}

		public byte[] ToByteArray()
		{
			return bytes.ToArray();
		}

		public string ToBase64()
		{
			if (MemoryMarshal.TryGetArray(bytes, out var segment))
			{
				return Convert.ToBase64String(segment.Array, segment.Offset, segment.Count);
			}
			return Convert.ToBase64String(bytes.ToArray());
		}

		public static ByteString FromBase64(string bytes)
		{
			if (!(bytes == ""))
			{
				return new ByteString(Convert.FromBase64String(bytes));
			}
			return Empty;
		}

		public static ByteString FromStream(Stream stream)
		{
			ProtoPreconditions.CheckNotNull(stream, "stream");
			MemoryStream memoryStream = new MemoryStream(stream.CanSeek ? checked((int)(stream.Length - stream.Position)) : 0);
			stream.CopyTo(memoryStream);
			return AttachBytes(memoryStream.ToArray());
		}

		public static Task<ByteString> FromStreamAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken))
		{
			ProtoPreconditions.CheckNotNull(stream, "stream");
			return ByteStringAsync.FromStreamAsyncCore(stream, cancellationToken);
		}

		public static ByteString CopyFrom(params byte[] bytes)
		{
			return new ByteString((byte[])bytes.Clone());
		}

		public static ByteString CopyFrom(byte[] bytes, int offset, int count)
		{
			byte[] array = new byte[count];
			ByteArray.Copy(bytes, offset, array, 0, count);
			return new ByteString(array);
		}

		public static ByteString CopyFrom(ReadOnlySpan<byte> bytes)
		{
			return new ByteString(bytes.ToArray());
		}

		public static ByteString CopyFrom(string text, Encoding encoding)
		{
			return new ByteString(encoding.GetBytes(text));
		}

		public static ByteString CopyFromUtf8(string text)
		{
			return CopyFrom(text, Encoding.UTF8);
		}

		public string ToString(Encoding encoding)
		{
			if (MemoryMarshal.TryGetArray(bytes, out var segment))
			{
				return encoding.GetString(segment.Array, segment.Offset, segment.Count);
			}
			byte[] array = bytes.ToArray();
			return encoding.GetString(array, 0, array.Length);
		}

		public string ToStringUtf8()
		{
			return ToString(Encoding.UTF8);
		}

		[SecuritySafeCritical]
		public IEnumerator<byte> GetEnumerator()
		{
			return MemoryMarshal.ToEnumerable(bytes).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public CodedInputStream CreateCodedInput()
		{
			if (MemoryMarshal.TryGetArray(bytes, out var segment) && segment.Count == bytes.Length)
			{
				return new CodedInputStream(segment.Array, segment.Offset, segment.Count);
			}
			return new CodedInputStream(bytes.ToArray());
		}

		public static bool operator ==(ByteString lhs, ByteString rhs)
		{
			if ((object)lhs == rhs)
			{
				return true;
			}
			if ((object)lhs == null || (object)rhs == null)
			{
				return false;
			}
			return lhs.bytes.Span.SequenceEqual(rhs.bytes.Span);
		}

		public static bool operator !=(ByteString lhs, ByteString rhs)
		{
			return !(lhs == rhs);
		}

		[SecuritySafeCritical]
		public override bool Equals(object obj)
		{
			return this == obj as ByteString;
		}

		[SecuritySafeCritical]
		public override int GetHashCode()
		{
			ReadOnlySpan<byte> span = bytes.Span;
			int num = 23;
			for (int i = 0; i < span.Length; i++)
			{
				num = num * 31 + span[i];
			}
			return num;
		}

		public bool Equals(ByteString other)
		{
			return this == other;
		}

		public void CopyTo(byte[] array, int position)
		{
			bytes.CopyTo(array.AsMemory(position));
		}

		public void WriteTo(Stream outputStream)
		{
			if (MemoryMarshal.TryGetArray(bytes, out var segment))
			{
				outputStream.Write(segment.Array, segment.Offset, segment.Count);
				return;
			}
			byte[] array = bytes.ToArray();
			outputStream.Write(array, 0, array.Length);
		}
	}
	internal static class ByteStringAsync
	{
		internal static async Task<ByteString> FromStreamAsyncCore(Stream stream, CancellationToken cancellationToken)
		{
			int capacity = (stream.CanSeek ? checked((int)(stream.Length - stream.Position)) : 0);
			MemoryStream memoryStream = new MemoryStream(capacity);
			await stream.CopyToAsync(memoryStream, 81920, cancellationToken);
			return ByteString.AttachBytes((memoryStream.Length == memoryStream.Capacity) ? memoryStream.GetBuffer() : memoryStream.ToArray());
		}
	}
	[SecuritySafeCritical]
	public sealed class CodedInputStream : IDisposable
	{
		private readonly bool leaveOpen;

		private readonly byte[] buffer;

		private readonly Stream input;

		private ParserInternalState state;

		internal const int DefaultRecursionLimit = 100;

		internal const int DefaultSizeLimit = int.MaxValue;

		internal const int BufferSize = 4096;

		public long Position
		{
			get
			{
				if (input != null)
				{
					return input.Position - (state.bufferSize + state.bufferSizeAfterLimit - state.bufferPos);
				}
				return state.bufferPos;
			}
		}

		internal uint LastTag => state.lastTag;

		public int SizeLimit => state.sizeLimit;

		public int RecursionLimit => state.recursionLimit;

		internal bool DiscardUnknownFields
		{
			get
			{
				return state.DiscardUnknownFields;
			}
			set
			{
				state.DiscardUnknownFields = value;
			}
		}

		internal ExtensionRegistry ExtensionRegistry
		{
			get
			{
				return state.ExtensionRegistry;
			}
			set
			{
				state.ExtensionRegistry = value;
			}
		}

		internal byte[] InternalBuffer => buffer;

		internal Stream InternalInputStream => input;

		internal ref ParserInternalState InternalState => ref state;

		internal bool ReachedLimit => SegmentedBufferHelper.IsReachedLimit(ref state);

		public bool IsAtEnd
		{
			get
			{
				ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
				return SegmentedBufferHelper.IsAtEnd(ref readOnlySpan, ref state);
			}
		}

		public CodedInputStream(byte[] buffer)
			: this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), 0, buffer.Length, leaveOpen: true)
		{
		}

		public CodedInputStream(byte[] buffer, int offset, int length)
			: this(null, ProtoPreconditions.CheckNotNull(buffer, "buffer"), offset, offset + length, leaveOpen: true)
		{
			if (offset < 0 || offset > buffer.Length)
			{
				throw new ArgumentOutOfRangeException("offset", "Offset must be within the buffer");
			}
			if (length < 0 || offset + length > buffer.Length)
			{
				throw new ArgumentOutOfRangeException("length", "Length must be non-negative and within the buffer");
			}
		}

		public CodedInputStream(Stream input)
			: this(input, leaveOpen: false)
		{
		}

		public CodedInputStream(Stream input, bool leaveOpen)
			: this(ProtoPreconditions.CheckNotNull(input, "input"), new byte[4096], 0, 0, leaveOpen)
		{
		}

		internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, bool leaveOpen)
		{
			this.input = input;
			this.buffer = buffer;
			state.bufferPos = bufferPos;
			state.bufferSize = bufferSize;
			state.sizeLimit = int.MaxValue;
			state.recursionLimit = 100;
			SegmentedBufferHelper.Initialize(this, out state.segmentedBufferHelper);
			this.leaveOpen = leaveOpen;
			state.currentLimit = int.MaxValue;
		}

		internal CodedInputStream(Stream input, byte[] buffer, int bufferPos, int bufferSize, int sizeLimit, int recursionLimit, bool leaveOpen)
			: this(input, buffer, bufferPos, bufferSize, leaveOpen)
		{
			if (sizeLimit <= 0)
			{
				throw new ArgumentOutOfRangeException("sizeLimit", "Size limit must be positive");
			}
			if (recursionLimit <= 0)
			{
				throw new ArgumentOutOfRangeException("recursionLimit!", "Recursion limit must be positive");
			}
			state.sizeLimit = sizeLimit;
			state.recursionLimit = recursionLimit;
		}

		public static CodedInputStream CreateWithLimits(Stream input, int sizeLimit, int recursionLimit)
		{
			return new CodedInputStream(input, new byte[4096], 0, 0, sizeLimit, recursionLimit, leaveOpen: false);
		}

		public void Dispose()
		{
			if (!leaveOpen)
			{
				input.Dispose();
			}
		}

		internal void CheckReadEndOfStreamTag()
		{
			ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref state);
		}

		public uint PeekTag()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.PeekTag(ref readOnlySpan, ref state);
		}

		public uint ReadTag()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseTag(ref readOnlySpan, ref state);
		}

		public void SkipLastField()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			ParsingPrimitivesMessages.SkipLastField(ref readOnlySpan, ref state);
		}

		internal void SkipGroup(uint startGroupTag)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			ParsingPrimitivesMessages.SkipGroup(ref readOnlySpan, ref state, startGroupTag);
		}

		public double ReadDouble()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseDouble(ref readOnlySpan, ref state);
		}

		public float ReadFloat()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseFloat(ref readOnlySpan, ref state);
		}

		public ulong ReadUInt64()
		{
			return ReadRawVarint64();
		}

		public long ReadInt64()
		{
			return (long)ReadRawVarint64();
		}

		public int ReadInt32()
		{
			return (int)ReadRawVarint32();
		}

		public ulong ReadFixed64()
		{
			return ReadRawLittleEndian64();
		}

		public uint ReadFixed32()
		{
			return ReadRawLittleEndian32();
		}

		public bool ReadBool()
		{
			return ReadRawVarint64() != 0;
		}

		public string ReadString()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ReadString(ref readOnlySpan, ref state);
		}

		public void ReadMessage(IMessage builder)
		{
			ParseContext.Initialize(buffer.AsSpan(), ref state, out var ctx);
			try
			{
				ParsingPrimitivesMessages.ReadMessage(ref ctx, builder);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}

		public void ReadGroup(IMessage builder)
		{
			ParseContext.Initialize(this, out var ctx);
			try
			{
				ParsingPrimitivesMessages.ReadGroup(ref ctx, builder);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}

		public ByteString ReadBytes()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ReadBytes(ref readOnlySpan, ref state);
		}

		public uint ReadUInt32()
		{
			return ReadRawVarint32();
		}

		public int ReadEnum()
		{
			return (int)ReadRawVarint32();
		}

		public int ReadSFixed32()
		{
			return (int)ReadRawLittleEndian32();
		}

		public long ReadSFixed64()
		{
			return (long)ReadRawLittleEndian64();
		}

		public int ReadSInt32()
		{
			return ParsingPrimitives.DecodeZigZag32(ReadRawVarint32());
		}

		public long ReadSInt64()
		{
			return ParsingPrimitives.DecodeZigZag64(ReadRawVarint64());
		}

		public int ReadLength()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseLength(ref readOnlySpan, ref state);
		}

		public bool MaybeConsumeTag(uint tag)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.MaybeConsumeTag(ref readOnlySpan, ref state, tag);
		}

		internal uint ReadRawVarint32()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseRawVarint32(ref readOnlySpan, ref state);
		}

		internal static uint ReadRawVarint32(Stream input)
		{
			return ParsingPrimitives.ReadRawVarint32(input);
		}

		internal ulong ReadRawVarint64()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseRawVarint64(ref readOnlySpan, ref state);
		}

		internal uint ReadRawLittleEndian32()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseRawLittleEndian32(ref readOnlySpan, ref state);
		}

		internal ulong ReadRawLittleEndian64()
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ParseRawLittleEndian64(ref readOnlySpan, ref state);
		}

		internal int PushLimit(int byteLimit)
		{
			return SegmentedBufferHelper.PushLimit(ref state, byteLimit);
		}

		internal void PopLimit(int oldLimit)
		{
			SegmentedBufferHelper.PopLimit(ref state, oldLimit);
		}

		private bool RefillBuffer(bool mustSucceed)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return state.segmentedBufferHelper.RefillBuffer(ref readOnlySpan, ref state, mustSucceed);
		}

		internal byte[] ReadRawBytes(int size)
		{
			ReadOnlySpan<byte> readOnlySpan = new ReadOnlySpan<byte>(buffer);
			return ParsingPrimitives.ReadRawBytes(ref readOnlySpan, ref state, size);
		}

		public void ReadRawMessage(IMessage message)
		{
			ParseContext.Initialize(this, out var ctx);
			try
			{
				ParsingPrimitivesMessages.ReadRawMessage(ref ctx, message);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}
	}
	[SecuritySafeCritical]
	public sealed class CodedOutputStream : IDisposable
	{
		public sealed class OutOfSpaceException : IOException
		{
			internal OutOfSpaceException()
				: base("CodedOutputStream was writing to a flat byte array and ran out of space.")
			{
			}
		}

		private const int LittleEndian64Size = 8;

		private const int LittleEndian32Size = 4;

		internal const int DoubleSize = 8;

		internal const int FloatSize = 4;

		internal const int BoolSize = 1;

		public static readonly int DefaultBufferSize = 4096;

		private readonly bool leaveOpen;

		private readonly byte[] buffer;

		private WriterInternalState state;

		private readonly Stream output;

		public long Position
		{
			get
			{
				if (output != null)
				{
					return output.Position + state.position;
				}
				return state.position;
			}
		}

		public int SpaceLeft => WriteBufferHelper.GetSpaceLeft(ref state);

		internal byte[] InternalBuffer => buffer;

		internal Stream InternalOutputStream => output;

		internal ref WriterInternalState InternalState => ref state;

		public static int ComputeDoubleSize(double value)
		{
			return 8;
		}

		public static int ComputeFloatSize(float value)
		{
			return 4;
		}

		public static int ComputeUInt64Size(ulong value)
		{
			return ComputeRawVarint64Size(value);
		}

		public static int ComputeInt64Size(long value)
		{
			return ComputeRawVarint64Size((ulong)value);
		}

		public static int ComputeInt32Size(int value)
		{
			if (value >= 0)
			{
				return ComputeRawVarint32Size((uint)value);
			}
			return 10;
		}

		public static int ComputeFixed64Size(ulong value)
		{
			return 8;
		}

		public static int ComputeFixed32Size(uint value)
		{
			return 4;
		}

		public static int ComputeBoolSize(bool value)
		{
			return 1;
		}

		public static int ComputeStringSize(string value)
		{
			int byteCount = WritingPrimitives.Utf8Encoding.GetByteCount(value);
			return ComputeLengthSize(byteCount) + byteCount;
		}

		public static int ComputeGroupSize(IMessage value)
		{
			return value.CalculateSize();
		}

		public static int ComputeMessageSize(IMessage value)
		{
			int num = value.CalculateSize();
			return ComputeLengthSize(num) + num;
		}

		public static int ComputeBytesSize(ByteString value)
		{
			return ComputeLengthSize(value.Length) + value.Length;
		}

		public static int ComputeUInt32Size(uint value)
		{
			return ComputeRawVarint32Size(value);
		}

		public static int ComputeEnumSize(int value)
		{
			return ComputeInt32Size(value);
		}

		public static int ComputeSFixed32Size(int value)
		{
			return 4;
		}

		public static int ComputeSFixed64Size(long value)
		{
			return 8;
		}

		public static int ComputeSInt32Size(int value)
		{
			return ComputeRawVarint32Size(WritingPrimitives.EncodeZigZag32(value));
		}

		public static int ComputeSInt64Size(long value)
		{
			return ComputeRawVarint64Size(WritingPrimitives.EncodeZigZag64(value));
		}

		public static int ComputeLengthSize(int length)
		{
			return ComputeRawVarint32Size((uint)length);
		}

		public static int ComputeRawVarint32Size(uint value)
		{
			if ((value & 0xFFFFFF80u) == 0)
			{
				return 1;
			}
			if ((value & 0xFFFFC000u) == 0)
			{
				return 2;
			}
			if ((value & 0xFFE00000u) == 0)
			{
				return 3;
			}
			if ((value & 0xF0000000u) == 0)
			{
				return 4;
			}
			return 5;
		}

		public static int ComputeRawVarint64Size(ulong value)
		{
			if ((value & 0xFFFFFFFFFFFFFF80uL) == 0L)
			{
				return 1;
			}
			if ((value & 0xFFFFFFFFFFFFC000uL) == 0L)
			{
				return 2;
			}
			if ((value & 0xFFFFFFFFFFE00000uL) == 0L)
			{
				return 3;
			}
			if ((value & 0xFFFFFFFFF0000000uL) == 0L)
			{
				return 4;
			}
			if ((value & 0xFFFFFFF800000000uL) == 0L)
			{
				return 5;
			}
			if ((value & 0xFFFFFC0000000000uL) == 0L)
			{
				return 6;
			}
			if ((value & 0xFFFE000000000000uL) == 0L)
			{
				return 7;
			}
			if ((value & 0xFF00000000000000uL) == 0L)
			{
				return 8;
			}
			if ((value & 0x8000000000000000uL) == 0L)
			{
				return 9;
			}
			return 10;
		}

		public static int ComputeTagSize(int fieldNumber)
		{
			return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.Varint));
		}

		public CodedOutputStream(byte[] flatArray)
			: this(flatArray, 0, flatArray.Length)
		{
		}

		private CodedOutputStream(byte[] buffer, int offset, int length)
		{
			output = null;
			this.buffer = ProtoPreconditions.CheckNotNull(buffer, "buffer");
			state.position = offset;
			state.limit = offset + length;
			WriteBufferHelper.Initialize(this, out state.writeBufferHelper);
			leaveOpen = true;
		}

		private CodedOutputStream(Stream output, byte[] buffer, bool leaveOpen)
		{
			this.output = ProtoPreconditions.CheckNotNull(output, "output");
			this.buffer = buffer;
			state.position = 0;
			state.limit = buffer.Length;
			WriteBufferHelper.Initialize(this, out state.writeBufferHelper);
			this.leaveOpen = leaveOpen;
		}

		public CodedOutputStream(Stream output)
			: this(output, DefaultBufferSize, leaveOpen: false)
		{
		}

		public CodedOutputStream(Stream output, int bufferSize)
			: this(output, new byte[bufferSize], leaveOpen: false)
		{
		}

		public CodedOutputStream(Stream output, bool leaveOpen)
			: this(output, DefaultBufferSize, leaveOpen)
		{
		}

		public CodedOutputStream(Stream output, int bufferSize, bool leaveOpen)
			: this(output, new byte[bufferSize], leaveOpen)
		{
		}

		public void WriteDouble(double value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteDouble(ref span, ref state, value);
		}

		public void WriteFloat(float value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteFloat(ref span, ref state, value);
		}

		public void WriteUInt64(ulong value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteUInt64(ref span, ref state, value);
		}

		public void WriteInt64(long value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteInt64(ref span, ref state, value);
		}

		public void WriteInt32(int value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteInt32(ref span, ref state, value);
		}

		public void WriteFixed64(ulong value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteFixed64(ref span, ref state, value);
		}

		public void WriteFixed32(uint value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteFixed32(ref span, ref state, value);
		}

		public void WriteBool(bool value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteBool(ref span, ref state, value);
		}

		public void WriteString(string value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteString(ref span, ref state, value);
		}

		public void WriteMessage(IMessage value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WriteContext.Initialize(ref span, ref state, out var ctx);
			try
			{
				WritingPrimitivesMessages.WriteMessage(ref ctx, value);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}

		public void WriteRawMessage(IMessage value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WriteContext.Initialize(ref span, ref state, out var ctx);
			try
			{
				WritingPrimitivesMessages.WriteRawMessage(ref ctx, value);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}

		public void WriteGroup(IMessage value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WriteContext.Initialize(ref span, ref state, out var ctx);
			try
			{
				WritingPrimitivesMessages.WriteGroup(ref ctx, value);
			}
			finally
			{
				ctx.CopyStateTo(this);
			}
		}

		public void WriteBytes(ByteString value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteBytes(ref span, ref state, value);
		}

		public void WriteUInt32(uint value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteUInt32(ref span, ref state, value);
		}

		public void WriteEnum(int value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteEnum(ref span, ref state, value);
		}

		public void WriteSFixed32(int value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteSFixed32(ref span, ref state, value);
		}

		public void WriteSFixed64(long value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteSFixed64(ref span, ref state, value);
		}

		public void WriteSInt32(int value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteSInt32(ref span, ref state, value);
		}

		public void WriteSInt64(long value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteSInt64(ref span, ref state, value);
		}

		public void WriteLength(int length)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteLength(ref span, ref state, length);
		}

		public void WriteTag(int fieldNumber, WireFormat.WireType type)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteTag(ref span, ref state, fieldNumber, type);
		}

		public void WriteTag(uint tag)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteTag(ref span, ref state, tag);
		}

		public void WriteRawTag(byte b1)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawTag(ref span, ref state, b1);
		}

		public void WriteRawTag(byte b1, byte b2)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4, b5);
		}

		internal void WriteRawVarint32(uint value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawVarint32(ref span, ref state, value);
		}

		internal void WriteRawVarint64(ulong value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawVarint64(ref span, ref state, value);
		}

		internal void WriteRawLittleEndian32(uint value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawLittleEndian32(ref span, ref state, value);
		}

		internal void WriteRawLittleEndian64(ulong value)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawLittleEndian64(ref span, ref state, value);
		}

		internal void WriteRawBytes(byte[] value)
		{
			WriteRawBytes(value, 0, value.Length);
		}

		internal void WriteRawBytes(byte[] value, int offset, int length)
		{
			Span<byte> span = new Span<byte>(buffer);
			WritingPrimitives.WriteRawBytes(ref span, ref state, value, offset, length);
		}

		public void Dispose()
		{
			Flush();
			if (!leaveOpen)
			{
				output.Dispose();
			}
		}

		public void Flush()
		{
			Span<byte> span = new Span<byte>(buffer);
			WriteBufferHelper.Flush(ref span, ref state);
		}

		public void CheckNoSpaceLeft()
		{
			WriteBufferHelper.CheckNoSpaceLeft(ref state);
		}
	}
	public abstract class Extension
	{
		internal abstract System.Type TargetType { get; }

		public int FieldNumber { get; }

		internal abstract bool IsRepeated { get; }

		protected Extension(int fieldNumber)
		{
			FieldNumber = fieldNumber;
		}

		internal abstract IExtensionValue CreateValue();
	}
	public sealed class Extension<TTarget, TValue> : Extension where TTarget : IExtendableMessage<TTarget>
	{
		private readonly FieldCodec<TValue> codec;

		internal TValue DefaultValue
		{
			get
			{
				if (codec == null)
				{
					return default(TValue);
				}
				return codec.DefaultValue;
			}
		}

		internal override System.Type TargetType => typeof(TTarget);

		internal override bool IsRepeated => false;

		public Extension(int fieldNumber, FieldCodec<TValue> codec)
			: base(fieldNumber)
		{
			this.codec = codec;
		}

		internal override IExtensionValue CreateValue()
		{
			return new ExtensionValue<TValue>(codec);
		}
	}
	public sealed class RepeatedExtension<TTarget, TValue> : Extension where TTarget : IExtendableMessage<TTarget>
	{
		private readonly FieldCodec<TValue> codec;

		internal override System.Type TargetType => typeof(TTarget);

		internal override bool IsRepeated => true;

		public RepeatedExtension(int fieldNumber, FieldCodec<TValue> codec)
			: base(fieldNumber)
		{
			this.codec = codec;
		}

		internal override IExtensionValue CreateValue()
		{
			return new RepeatedExtensionValue<TValue>(codec);
		}
	}
	public sealed class ExtensionRegistry : ICollection<Extension>, IEnumerable<Extension>, IEnumerable, IDeepCloneable<ExtensionRegistry>
	{
		internal sealed class ExtensionComparer : IEqualityComparer<Extension>
		{
			internal static ExtensionComparer Instance = new ExtensionComparer();

			public bool Equals(Extension a, Extension b)
			{
				return new ObjectIntPair<System.Type>(a.TargetType, a.FieldNumber).Equals(new ObjectIntPair<System.Type>(b.TargetType, b.FieldNumber));
			}

			public int GetHashCode(Extension a)
			{
				return new ObjectIntPair<System.Type>(a.TargetType, a.FieldNumber).GetHashCode();
			}
		}

		private IDictionary<ObjectIntPair<System.Type>, Extension> extensions;

		public int Count => extensions.Count;

		bool ICollection<Extension>.IsReadOnly => false;

		public ExtensionRegistry()
		{
			extensions = new Dictionary<ObjectIntPair<System.Type>, Extension>();
		}

		private ExtensionRegistry(IDictionary<ObjectIntPair<System.Type>, Extension> collection)
		{
			extensions = collection.ToDictionary((KeyValuePair<ObjectIntPair<System.Type>, Extension> k) => k.Key, (KeyValuePair<ObjectIntPair<System.Type>, Extension> v) => v.Value);
		}

		internal bool ContainsInputField(uint lastTag, System.Type target, out Extension extension)
		{
			return extensions.TryGetValue(new ObjectIntPair<System.Type>(target, WireFormat.GetTagFieldNumber(lastTag)), out extension);
		}

		public void Add(Extension extension)
		{
			ProtoPreconditions.CheckNotNull(extension, "extension");
			extensions.Add(new ObjectIntPair<System.Type>(extension.TargetType, extension.FieldNumber), extension);
		}

		public void AddRange(IEnumerable<Extension> extensions)
		{
			ProtoPreconditions.CheckNotNull(extensions, "extensions");
			foreach (Extension extension in extensions)
			{
				Add(extension);
			}
		}

		public void Clear()
		{
			extensions.Clear();
		}

		public bool Contains(Extension item)
		{
			ProtoPreconditions.CheckNotNull(item, "item");
			return extensions.ContainsKey(new ObjectIntPair<System.Type>(item.TargetType, item.FieldNumber));
		}

		void ICollection<Extension>.CopyTo(Extension[] array, int arrayIndex)
		{
			ProtoPreconditions.CheckNotNull(array, "array");
			if (arrayIndex < 0 || arrayIndex >= array.Length)
			{
				throw new ArgumentOutOfRangeException("arrayIndex");
			}
			if (array.Length - arrayIndex < Count)
			{
				throw new ArgumentException("The provided array is shorter than the number of elements in the registry");
			}
			foreach (Extension extension in array)
			{
				extensions.Add(new ObjectIntPair<System.Type>(extension.TargetType, extension.FieldNumber), extension);
			}
		}

		public IEnumerator<Extension> GetEnumerator()
		{
			return extensions.Values.GetEnumerator();
		}

		public bool Remove(Extension item)
		{
			ProtoPreconditions.CheckNotNull(item, "item");
			return extensions.Remove(new ObjectIntPair<System.Type>(item.TargetType, item.FieldNumber));
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public ExtensionRegistry Clone()
		{
			return new ExtensionRegistry(extensions);
		}
	}
	public static class ExtensionSet
	{
		private static bool TryGetValue<TTarget>(ref ExtensionSet<TTarget> set, Extension extension, out IExtensionValue value) where TTarget : IExtendableMessage<TTarget>
		{
			if (set == null)
			{
				value = null;
				return false;
			}
			return set.ValuesByNumber.TryGetValue(extension.FieldNumber, out value);
		}

		public static TValue Get<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			if (TryGetValue(ref set, extension, out var value))
			{
				if (value is ExtensionValue<TValue> extensionValue)
				{
					return extensionValue.GetValue();
				}
				object value2 = value.GetValue();
				if (value2 is TValue)
				{
					return (TValue)value2;
				}
				TypeInfo typeInfo = value.GetType().GetTypeInfo();
				if (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(ExtensionValue<>))
				{
					System.Type type = typeInfo.GenericTypeArguments[0];
					throw new InvalidOperationException("The stored extension value has a type of '" + type.AssemblyQualifiedName + "'. This a different from the requested type of '" + typeof(TValue).AssemblyQualifiedName + "'.");
				}
				throw new InvalidOperationException("Unexpected extension value type: " + typeInfo.AssemblyQualifiedName);
			}
			return extension.DefaultValue;
		}

		public static RepeatedField<TValue> Get<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			if (TryGetValue(ref set, extension, out var value))
			{
				if (value is RepeatedExtensionValue<TValue> repeatedExtensionValue)
				{
					return repeatedExtensionValue.GetValue();
				}
				TypeInfo typeInfo = value.GetType().GetTypeInfo();
				if (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(RepeatedExtensionValue<>))
				{
					System.Type type = typeInfo.GenericTypeArguments[0];
					throw new InvalidOperationException("The stored extension value has a type of '" + type.AssemblyQualifiedName + "'. This a different from the requested type of '" + typeof(TValue).AssemblyQualifiedName + "'.");
				}
				throw new InvalidOperationException("Unexpected extension value type: " + typeInfo.AssemblyQualifiedName);
			}
			return null;
		}

		public static RepeatedField<TValue> GetOrInitialize<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			IExtensionValue value;
			if (set == null)
			{
				value = extension.CreateValue();
				set = new ExtensionSet<TTarget>();
				set.ValuesByNumber.Add(extension.FieldNumber, value);
			}
			else if (!set.ValuesByNumber.TryGetValue(extension.FieldNumber, out value))
			{
				value = extension.CreateValue();
				set.ValuesByNumber.Add(extension.FieldNumber, value);
			}
			return ((RepeatedExtensionValue<TValue>)value).GetValue();
		}

		public static void Set<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension, TValue value) where TTarget : IExtendableMessage<TTarget>
		{
			ProtoPreconditions.CheckNotNullUnconstrained(value, "value");
			IExtensionValue value2;
			if (set == null)
			{
				value2 = extension.CreateValue();
				set = new ExtensionSet<TTarget>();
				set.ValuesByNumber.Add(extension.FieldNumber, value2);
			}
			else if (!set.ValuesByNumber.TryGetValue(extension.FieldNumber, out value2))
			{
				value2 = extension.CreateValue();
				set.ValuesByNumber.Add(extension.FieldNumber, value2);
			}
			((ExtensionValue<TValue>)value2).SetValue(value);
		}

		public static bool Has<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			IExtensionValue value;
			return TryGetValue(ref set, extension, out value);
		}

		public static void Clear<TTarget, TValue>(ref ExtensionSet<TTarget> set, Extension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			if (set != null)
			{
				set.ValuesByNumber.Remove(extension.FieldNumber);
				if (set.ValuesByNumber.Count == 0)
				{
					set = null;
				}
			}
		}

		public static void Clear<TTarget, TValue>(ref ExtensionSet<TTarget> set, RepeatedExtension<TTarget, TValue> extension) where TTarget : IExtendableMessage<TTarget>
		{
			if (set != null)
			{
				set.ValuesByNumber.Remove(extension.FieldNumber);
				if (set.ValuesByNumber.Count == 0)
				{
					set = null;
				}
			}
		}

		public static bool TryMergeFieldFrom<TTarget>(ref ExtensionSet<TTarget> set, CodedInputStream stream) where TTarget : IExtendableMessage<TTarget>
		{
			ParseContext.Initialize(stream, out var ctx);
			try
			{
				return TryMergeFieldFrom(ref set, ref ctx);
			}
			finally
			{
				ctx.CopyStateTo(stream);
			}
		}

		public static bool TryMergeFieldFrom<TTarget>(ref ExtensionSet<TTarget> set, ref ParseContext ctx) where TTarget : IExtendableMessage<TTarget>
		{
			int tagFieldNumber = WireFormat.GetTagFieldNumber(ctx.LastTag);
			if (set != null && set.ValuesByNumber.TryGetValue(tagFieldNumber, out var value))
			{
				value.MergeFrom(ref ctx);
				return true;
			}
			if (ctx.ExtensionRegistry != null && ctx.ExtensionRegistry.ContainsInputField(ctx.LastTag, typeof(TTarget), out var extension))
			{
				IExtensionValue extensionValue = extension.CreateValue();
				extensionValue.MergeFrom(ref ctx);
				set = set ?? new ExtensionSet<TTarget>();
				set.ValuesByNumber.Add(extension.FieldNumber, extensionValue);
				return true;
			}
			return false;
		}

		public static void MergeFrom<TTarget>(ref ExtensionSet<TTarget> first, ExtensionSet<TTarget> second) where TTarget : IExtendableMessage<TTarget>
		{
			if (second == null)
			{
				return;
			}
			if (first == null)
			{
				first = new ExtensionSet<TTarget>();
			}
			foreach (KeyValuePair<int, IExtensionValue> item in second.ValuesByNumber)
			{
				if (first.ValuesByNumber.TryGetValue(item.Key, out var value))
				{
					value.MergeFrom(item.Value);
					continue;
				}
				IExtensionValue value2 = item.Value.Clone();
				first.ValuesByNumber[item.Key] = value2;
			}
		}

		public static ExtensionSet<TTarget> Clone<TTarget>(ExtensionSet<TTarget> set) where TTarget : IExtendableMessage<TTarget>
		{
			if (set == null)
			{
				return null;
			}
			ExtensionSet<TTarget> extensionSet = new ExtensionSet<TTarget>();
			foreach (KeyValuePair<int, IExtensionValue> item in set.ValuesByNumber)
			{
				IExtensionValue value = item.Value.Clone();
				extensionSet.ValuesByNumber[item.Key] = value;
			}
			return extensionSet;
		}
	}
	public sealed class ExtensionSet<TTarget> where TTarget : IExtendableMessage<TTarget>
	{
		internal Dictionary<int, IExtensionValue> ValuesByNumber { get; } = new Dictionary<int, IExtensionValue>();

		public override int GetHashCode()
		{
			int num = typeof(TTarget).GetHashCode();
			foreach (KeyValuePair<int, IExtensionValue> item in ValuesByNumber)
			{
				int num2 = item.Key.GetHashCode() ^ item.Value.GetHashCode();
				num ^= num2;
			}
			return num;
		}

		public override bool Equals(object other)
		{
			if (this == other)
			{
				return true;
			}
			ExtensionSet<TTarget> extensionSet = other as ExtensionSet<TTarget>;
			if (ValuesByNumber.Count != extensionSet.ValuesByNumber.Count)
			{
				return false;
			}
			foreach (KeyValuePair<int, IExtensionValue> item in ValuesByNumber)
			{
				if (!extensionSet.ValuesByNumber.TryGetValue(item.Key, out var value))
				{
					return false;
				}
				if (!item.Value.Equals(value))
				{
					return false;
				}
			}
			return true;
		}

		public int CalculateSize()
		{
			int num = 0;
			foreach (IExtensionValue value in ValuesByNumber.Values)
			{
				num += value.CalculateSize();
			}
			return num;
		}

		public void WriteTo(CodedOutputStream stream)
		{
			WriteContext.Initialize(stream, out var ctx);
			try
			{
				WriteTo(ref ctx);
			}
			finally
			{
				ctx.CopyStateTo(stream);
			}
		}

		[SecuritySafeCritical]
		public void WriteTo(ref WriteContext ctx)
		{
			foreach (IExtensionValue value in ValuesByNumber.Values)
			{
				value.WriteTo(ref ctx);
			}
		}

		internal bool IsInitialized()
		{
			return ValuesByNumber.Values.All((IExtensionValue v) => v.IsInitialized());
		}
	}
	internal interface IExtensionValue : IEquatable<IExtensionValue>, IDeepCloneable<IExtensionValue>
	{
		void MergeFrom(ref ParseContext ctx);

		void MergeFrom(IExtensionValue value);

		void WriteTo(ref WriteContext ctx);

		int CalculateSize();

		bool IsInitialized();

		object GetValue();
	}
	internal sealed class ExtensionValue<T> : IExtensionValue, IEquatable<IExtensionValue>, IDeepCloneable<IExtensionValue>
	{
		private T field;

		private FieldCodec<T> codec;

		internal ExtensionValue(FieldCodec<T> codec)
		{
			this.codec = codec;
			field = codec.DefaultValue;
		}

		public int CalculateSize()
		{
			return codec.CalculateUnconditionalSizeWithTag(field);
		}

		public IExtensionValue Clone()
		{
			return new ExtensionValue<T>(codec)
			{
				field = ((field is IDeepCloneable<T>) ? (field as IDeepCloneable<T>).Clone() : field)
			};
		}

		public bool Equals(IExtensionValue other)
		{
			if (this == other)
			{
				return true;
			}
			if (other is ExtensionValue<T> && codec.Equals((other as ExtensionValue<T>).codec))
			{
				return object.Equals(field, (other as ExtensionValue<T>).field);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (17 * 31 + field.GetHashCode()) * 31 + codec.GetHashCode();
		}

		public void MergeFrom(ref ParseContext ctx)
		{
			codec.ValueMerger(ref ctx, ref field);
		}

		public void MergeFrom(IExtensionValue value)
		{
			if (value is ExtensionValue<T>)
			{
				ExtensionValue<T> extensionValue = value as ExtensionValue<T>;
				codec.FieldMerger(ref field, extensionValue.field);
			}
		}

		public void WriteTo(ref WriteContext ctx)
		{
			ctx.WriteTag(codec.Tag);
			codec.ValueWriter(ref ctx, field);
			if (codec.EndTag != 0)
			{
				ctx.WriteTag(codec.EndTag);
			}
		}

		public T GetValue()
		{
			return field;
		}

		object IExtensionValue.GetValue()
		{
			return field;
		}

		public void SetValue(T value)
		{
			field = value;
		}

		public bool IsInitialized()
		{
			if (field is IMessage)
			{
				return (field as IMessage).IsInitialized();
			}
			return true;
		}
	}
	internal sealed class RepeatedExtensionValue<T> : IExtensionValue, IEquatable<IExtensionValue>, IDeepCloneable<IExtensionValue>
	{
		private RepeatedField<T> field;

		private readonly FieldCodec<T> codec;

		internal RepeatedExtensionValue(FieldCodec<T> codec)
		{
			this.codec = codec;
			field = new RepeatedField<T>();
		}

		public int CalculateSize()
		{
			return field.CalculateSize(codec);
		}

		public IExtensionValue Clone()
		{
			return new RepeatedExtensionValue<T>(codec)
			{
				field = field.Clone()
			};
		}

		public bool Equals(IExtensionValue other)
		{
			if (this == other)
			{
				return true;
			}
			if (other is RepeatedExtensionValue<T> && field.Equals((other as RepeatedExtensionValue<T>).field))
			{
				return codec.Equals((other as RepeatedExtensionValue<T>).codec);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (17 * 31 + field.GetHashCode()) * 31 + codec.GetHashCode();
		}

		public void MergeFrom(ref ParseContext ctx)
		{
			field.AddEntriesFrom(ref ctx, codec);
		}

		public void MergeFrom(IExtensionValue value)
		{
			if (value is RepeatedExtensionValue<T>)
			{
				field.Add((value as RepeatedExtensionValue<T>).field);
			}
		}

		public void WriteTo(ref WriteContext ctx)
		{
			field.WriteTo(ref ctx, codec);
		}

		public RepeatedField<T> GetValue()
		{
			return field;
		}

		object IExtensionValue.GetValue()
		{
			return field;
		}

		public bool IsInitialized()
		{
			for (int i = 0; i < field.Count; i++)
			{
				T val = field[i];
				if (!(val is IMessage))
				{
					break;
				}
				if (!(val as IMessage).IsInitialized())
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class FieldCodec
	{
		private static class WrapperCodecs
		{
			private static readonly Dictionary<System.Type, object> Codecs = new Dictionary<System.Type, object>
			{
				{
					typeof(bool),
					ForBool(WireFormat.MakeTag(1, WireFormat.WireType.Varint))
				},
				{
					typeof(int),
					ForInt32(WireFormat.MakeTag(1, WireFormat.WireType.Varint))
				},
				{
					typeof(long),
					ForInt64(WireFormat.MakeTag(1, WireFormat.WireType.Varint))
				},
				{
					typeof(uint),
					ForUInt32(WireFormat.MakeTag(1, WireFormat.WireType.Varint))
				},
				{
					typeof(ulong),
					ForUInt64(WireFormat.MakeTag(1, WireFormat.WireType.Varint))
				},
				{
					typeof(float),
					ForFloat(WireFormat.MakeTag(1, WireFormat.WireType.Fixed32))
				},
				{
					typeof(double),
					ForDouble(WireFormat.MakeTag(1, WireFormat.WireType.Fixed64))
				},
				{
					typeof(string),
					ForString(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited))
				},
				{
					typeof(ByteString),
					ForBytes(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited))
				}
			};

			private static readonly Dictionary<System.Type, object> Readers = new Dictionary<System.Type, object>
			{
				{
					typeof(bool),
					new ValueReader<bool?>(ParsingPrimitivesWrappers.ReadBoolWrapper)
				},
				{
					typeof(int),
					new ValueReader<int?>(ParsingPrimitivesWrappers.ReadInt32Wrapper)
				},
				{
					typeof(long),
					new ValueReader<long?>(ParsingPrimitivesWrappers.ReadInt64Wrapper)
				},
				{
					typeof(uint),
					new ValueReader<uint?>(ParsingPrimitivesWrappers.ReadUInt32Wrapper)
				},
				{
					typeof(ulong),
					new ValueReader<ulong?>(ParsingPrimitivesWrappers.ReadUInt64Wrapper)
				},
				{
					typeof(float),
					BitConverter.IsLittleEndian ? new ValueReader<float?>(ParsingPrimitivesWrappers.ReadFloatWrapperLittleEndian) : new ValueReader<float?>(ParsingPrimitivesWrappers.ReadFloatWrapperSlow)
				},
				{
					typeof(double),
					BitConverter.IsLittleEndian ? new ValueReader<double?>(ParsingPrimitivesWrappers.ReadDoubleWrapperLittleEndian) : new ValueReader<double?>(ParsingPrimitivesWrappers.ReadDoubleWrapperSlow)
				},
				{
					typeof(string),
					null
				},
				{
					typeof(ByteString),
					null
				}
			};

			internal static FieldCodec<T> GetCodec<T>()
			{
				if (!Codecs.TryGetValue(typeof(T), out var value))
				{
					throw new InvalidOperationException("Invalid type argument requested for wrapper codec: " + typeof(T));
				}
				return (FieldCodec<T>)value;
			}

			internal static ValueReader<T?> GetReader<T>() where T : struct
			{
				if (!Readers.TryGetValue(typeof(T), out var value))
				{
					throw new InvalidOperationException("Invalid type argument requested for wrapper reader: " + typeof(T));
				}
				if (value == null)
				{
					FieldCodec<T> nestedCoded = GetCodec<T>();
					return delegate(ref ParseContext ctx)
					{
						return Read(ref ctx, nestedCoded);
					};
				}
				return (ValueReader<T?>)value;
			}

			[SecuritySafeCritical]
			internal static T Read<T>(ref ParseContext ctx, FieldCodec<T> codec)
			{
				int byteLimit = ctx.ReadLength();
				int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, byteLimit);
				T result = codec.DefaultValue;
				uint num;
				while ((num = ctx.ReadTag()) != 0)
				{
					if (num == codec.Tag)
					{
						result = codec.Read(ref ctx);
					}
					else
					{
						ParsingPrimitivesMessages.SkipLastField(ref ctx.buffer, ref ctx.state);
					}
				}
				ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref ctx.state);
				SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
				return result;
			}

			internal static void Write<T>(ref WriteContext ctx, T value, FieldCodec<T> codec)
			{
				ctx.WriteLength(codec.CalculateSizeWithTag(value));
				codec.WriteTagAndValue(ref ctx, value);
			}

			internal static int CalculateSize<T>(T value, FieldCodec<T> codec)
			{
				int num = codec.CalculateSizeWithTag(value);
				return CodedOutputStream.ComputeLengthSize(num) + num;
			}
		}

		public static FieldCodec<string> ForString(uint tag)
		{
			return ForString(tag, "");
		}

		public static FieldCodec<ByteString> ForBytes(uint tag)
		{
			return ForBytes(tag, ByteString.Empty);
		}

		public static FieldCodec<bool> ForBool(uint tag)
		{
			return ForBool(tag, defaultValue: false);
		}

		public static FieldCodec<int> ForInt32(uint tag)
		{
			return ForInt32(tag, 0);
		}

		public static FieldCodec<int> ForSInt32(uint tag)
		{
			return ForSInt32(tag, 0);
		}

		public static FieldCodec<uint> ForFixed32(uint tag)
		{
			return ForFixed32(tag, 0u);
		}

		public static FieldCodec<int> ForSFixed32(uint tag)
		{
			return ForSFixed32(tag, 0);
		}

		public static FieldCodec<uint> ForUInt32(uint tag)
		{
			return ForUInt32(tag, 0u);
		}

		public static FieldCodec<long> ForInt64(uint tag)
		{
			return ForInt64(tag, 0L);
		}

		public static FieldCodec<long> ForSInt64(uint tag)
		{
			return ForSInt64(tag, 0L);
		}

		public static FieldCodec<ulong> ForFixed64(uint tag)
		{
			return ForFixed64(tag, 0uL);
		}

		public static FieldCodec<long> ForSFixed64(uint tag)
		{
			return ForSFixed64(tag, 0L);
		}

		public static FieldCodec<ulong> ForUInt64(uint tag)
		{
			return ForUInt64(tag, 0uL);
		}

		public static FieldCodec<float> ForFloat(uint tag)
		{
			return ForFloat(tag, 0f);
		}

		public static FieldCodec<double> ForDouble(uint tag)
		{
			return ForDouble(tag, 0.0);
		}

		public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32)
		{
			return ForEnum(tag, toInt32, fromInt32, default(T));
		}

		public static FieldCodec<string> ForString(uint tag, string defaultValue)
		{
			return new FieldCodec<string>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadString();
			}, delegate(ref WriteContext ctx, string value)
			{
				ctx.WriteString(value);
			}, CodedOutputStream.ComputeStringSize, tag, defaultValue);
		}

		public static FieldCodec<ByteString> ForBytes(uint tag, ByteString defaultValue)
		{
			return new FieldCodec<ByteString>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadBytes();
			}, delegate(ref WriteContext ctx, ByteString value)
			{
				ctx.WriteBytes(value);
			}, CodedOutputStream.ComputeBytesSize, tag, defaultValue);
		}

		public static FieldCodec<bool> ForBool(uint tag, bool defaultValue)
		{
			return new FieldCodec<bool>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadBool();
			}, delegate(ref WriteContext ctx, bool value)
			{
				ctx.WriteBool(value);
			}, 1, tag, defaultValue);
		}

		public static FieldCodec<int> ForInt32(uint tag, int defaultValue)
		{
			return new FieldCodec<int>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadInt32();
			}, delegate(ref WriteContext output, int value)
			{
				output.WriteInt32(value);
			}, CodedOutputStream.ComputeInt32Size, tag, defaultValue);
		}

		public static FieldCodec<int> ForSInt32(uint tag, int defaultValue)
		{
			return new FieldCodec<int>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadSInt32();
			}, delegate(ref WriteContext output, int value)
			{
				output.WriteSInt32(value);
			}, CodedOutputStream.ComputeSInt32Size, tag, defaultValue);
		}

		public static FieldCodec<uint> ForFixed32(uint tag, uint defaultValue)
		{
			return new FieldCodec<uint>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadFixed32();
			}, delegate(ref WriteContext output, uint value)
			{
				output.WriteFixed32(value);
			}, 4, tag, defaultValue);
		}

		public static FieldCodec<int> ForSFixed32(uint tag, int defaultValue)
		{
			return new FieldCodec<int>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadSFixed32();
			}, delegate(ref WriteContext output, int value)
			{
				output.WriteSFixed32(value);
			}, 4, tag, defaultValue);
		}

		public static FieldCodec<uint> ForUInt32(uint tag, uint defaultValue)
		{
			return new FieldCodec<uint>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadUInt32();
			}, delegate(ref WriteContext output, uint value)
			{
				output.WriteUInt32(value);
			}, CodedOutputStream.ComputeUInt32Size, tag, defaultValue);
		}

		public static FieldCodec<long> ForInt64(uint tag, long defaultValue)
		{
			return new FieldCodec<long>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadInt64();
			}, delegate(ref WriteContext output, long value)
			{
				output.WriteInt64(value);
			}, CodedOutputStream.ComputeInt64Size, tag, defaultValue);
		}

		public static FieldCodec<long> ForSInt64(uint tag, long defaultValue)
		{
			return new FieldCodec<long>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadSInt64();
			}, delegate(ref WriteContext output, long value)
			{
				output.WriteSInt64(value);
			}, CodedOutputStream.ComputeSInt64Size, tag, defaultValue);
		}

		public static FieldCodec<ulong> ForFixed64(uint tag, ulong defaultValue)
		{
			return new FieldCodec<ulong>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadFixed64();
			}, delegate(ref WriteContext output, ulong value)
			{
				output.WriteFixed64(value);
			}, 8, tag, defaultValue);
		}

		public static FieldCodec<long> ForSFixed64(uint tag, long defaultValue)
		{
			return new FieldCodec<long>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadSFixed64();
			}, delegate(ref WriteContext output, long value)
			{
				output.WriteSFixed64(value);
			}, 8, tag, defaultValue);
		}

		public static FieldCodec<ulong> ForUInt64(uint tag, ulong defaultValue)
		{
			return new FieldCodec<ulong>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadUInt64();
			}, delegate(ref WriteContext output, ulong value)
			{
				output.WriteUInt64(value);
			}, CodedOutputStream.ComputeUInt64Size, tag, defaultValue);
		}

		public static FieldCodec<float> ForFloat(uint tag, float defaultValue)
		{
			return new FieldCodec<float>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadFloat();
			}, delegate(ref WriteContext output, float value)
			{
				output.WriteFloat(value);
			}, 4, tag, defaultValue);
		}

		public static FieldCodec<double> ForDouble(uint tag, double defaultValue)
		{
			return new FieldCodec<double>(delegate(ref ParseContext ctx)
			{
				return ctx.ReadDouble();
			}, delegate(ref WriteContext output, double value)
			{
				output.WriteDouble(value);
			}, 8, tag, defaultValue);
		}

		public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32, T defaultValue)
		{
			return new FieldCodec<T>(delegate(ref ParseContext ctx)
			{
				return fromInt32(ctx.ReadEnum());
			}, delegate(ref WriteContext output, T value)
			{
				output.WriteEnum(toInt32(value));
			}, (T value) => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag, defaultValue);
		}

		public static FieldCodec<T> ForMessage<T>(uint tag, MessageParser<T> parser) where T : class, IMessage<T>
		{
			return new FieldCodec<T>(delegate(ref ParseContext ctx)
			{
				T val = parser.CreateTemplate();
				ctx.ReadMessage(val);
				return val;
			}, delegate(ref WriteContext output, T value)
			{
				output.WriteMessage(value);
			}, delegate(ref ParseContext ctx, ref T v)
			{
				if (v == null)
				{
					v = parser.CreateTemplate();
				}
				ctx.ReadMessage(v);
			}, delegate(ref T v, T v2)
			{
				if (v2 == null)
				{
					return false;
				}
				if (v == null)
				{
					v = v2.Clone();
				}
				else
				{
					v.MergeFrom(v2);
				}
				return true;
			}, (T message) => CodedOutputStream.ComputeMessageSize(message), tag);
		}

		public static FieldCodec<T> ForGroup<T>(uint startTag, uint endTag, MessageParser<T> parser) where T : class, IMessage<T>
		{
			return new FieldCodec<T>(delegate(ref ParseContext ctx)
			{
				T val = parser.CreateTemplate();
				ctx.ReadGroup(val);
				return val;
			}, delegate(ref WriteContext output, T value)
			{
				output.WriteGroup(value);
			}, delegate(ref ParseContext ctx, ref T v)
			{
				if (v == null)
				{
					v = parser.CreateTemplate();
				}
				ctx.ReadGroup(v);
			}, delegate(ref T v, T v2)
			{
				if (v2 == null)
				{
					return v == null;
				}
				if (v == null)
				{
					v = v2.Clone();
				}
				else
				{
					v.MergeFrom(v2);
				}
				return true;
			}, (T message) => CodedOutputStream.ComputeGroupSize(message), startTag, endTag);
		}

		public static FieldCodec<T> ForClassWrapper<T>(uint tag) where T : class
		{
			FieldCodec<T> nestedCodec = WrapperCodecs.GetCodec<T>();
			return new FieldCodec<T>(delegate(ref ParseContext ctx)
			{
				return WrapperCodecs.Read(ref ctx, nestedCodec);
			}, delegate(ref WriteContext output, T value)
			{
				WrapperCodecs.Write(ref output, value, nestedCodec);
			}, delegate(ref ParseContext ctx, ref T v)
			{
				v = WrapperCodecs.Read(ref ctx, nestedCodec);
			}, delegate(ref T v, T v2)
			{
				v = v2;
				return v == null;
			}, (T value) => WrapperCodecs.CalculateSize(value, nestedCodec), tag, 0u, null);
		}

		public static FieldCodec<T?> ForStructWrapper<T>(uint tag) where T : struct
		{
			FieldCodec<T> nestedCodec = WrapperCodecs.GetCodec<T>();
			return new FieldCodec<T?>(WrapperCodecs.GetReader<T>(), delegate(ref WriteContext output, T? value)
			{
				WrapperCodecs.Write(ref output, value.Value, nestedCodec);
			}, delegate(ref ParseContext ctx, ref T? v)
			{
				v = WrapperCodecs.Read(ref ctx, nestedCodec);
			}, delegate(ref T? v, T? v2)
			{
				if (v2.HasValue)
				{
					v = v2;
				}
				return v.HasValue;
			}, (T? value) => value.HasValue ? WrapperCodecs.CalculateSize(value.Value, nestedCodec) : 0, tag, 0u, null);
		}
	}
	internal delegate TValue ValueReader<out TValue>(ref ParseContext ctx);
	internal delegate void ValueWriter<T>(ref WriteContext ctx, T value);
	public sealed class FieldCodec<T>
	{
		internal delegate void InputMerger(ref ParseContext ctx, ref T value);

		internal delegate bool ValuesMerger(ref T value, T other);

		private static readonly EqualityComparer<T> EqualityComparer;

		private static readonly T DefaultDefault;

		private static readonly bool TypeSupportsPacking;

		private readonly int tagSize;

		internal bool PackedRepeatedField { get; }

		internal ValueWriter<T> ValueWriter { get; }

		internal Func<T, int> ValueSizeCalculator { get; }

		internal ValueReader<T> ValueReader { get; }

		internal InputMerger ValueMerger { get; }

		internal ValuesMerger FieldMerger { get; }

		internal int FixedSize { get; }

		internal uint Tag { get; }

		internal uint EndTag { get; }

		internal T DefaultValue { get; }

		static FieldCodec()
		{
			EqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<T>();
			TypeSupportsPacking = default(T) != null;
			if (typeof(T) == typeof(string))
			{
				DefaultDefault = (T)(object)"";
			}
			else if (typeof(T) == typeof(ByteString))
			{
				DefaultDefault = (T)(object)ByteString.Empty;
			}
		}

		internal static bool IsPackedRepeatedField(uint tag)
		{
			if (TypeSupportsPacking)
			{
				return WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited;
			}
			return false;
		}

		internal FieldCodec(ValueReader<T> reader, ValueWriter<T> writer, int fixedSize, uint tag, T defaultValue)
			: this(reader, writer, (Func<T, int>)((T _) => fixedSize), tag, defaultValue)
		{
			FixedSize = fixedSize;
		}

		internal FieldCodec(ValueReader<T> reader, ValueWriter<T> writer, Func<T, int> sizeCalculator, uint tag, T defaultValue)
			: this(reader, writer, (InputMerger)delegate(ref ParseContext ctx, ref T v)
			{
				v = reader(ref ctx);
			}, (ValuesMerger)delegate(ref T v, T v2)
			{
				v = v2;
				return true;
			}, sizeCalculator, tag, 0u, defaultValue)
		{
		}

		internal FieldCodec(ValueReader<T> reader, ValueWriter<T> writer, InputMerger inputMerger, ValuesMerger valuesMerger, Func<T, int> sizeCalculator, uint tag, uint endTag = 0u)
			: this(reader, writer, inputMerger, valuesMerger, sizeCalculator, tag, endTag, DefaultDefault)
		{
		}

		internal FieldCodec(ValueReader<T> reader, ValueWriter<T> writer, InputMerger inputMerger, ValuesMerger valuesMerger, Func<T, int> sizeCalculator, uint tag, uint endTag, T defaultValue)
		{
			ValueReader = reader;
			ValueWriter = writer;
			ValueMerger = inputMerger;
			FieldMerger = valuesMerger;
			ValueSizeCalculator = sizeCalculator;
			FixedSize = 0;
			Tag = tag;
			EndTag = endTag;
			DefaultValue = defaultValue;
			tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
			if (endTag != 0)
			{
				tagSize += CodedOutputStream.ComputeRawVarint32Size(endTag);
			}
			PackedRepeatedField = IsPackedRepeatedField(tag);
		}

		public void WriteTagAndValue(CodedOutputStream output, T value)
		{
			WriteContext.Initialize(output, out var ctx);
			try
			{
				WriteTagAndValue(ref ctx, value);
			}
			finally
			{
				ctx.CopyStateTo(output);
			}
		}

		public void WriteTagAndValue(ref WriteContext ctx, T value)
		{
			if (!IsDefault(value))
			{
				ctx.WriteTag(Tag);
				ValueWriter(ref ctx, value);
				if (EndTag != 0)
				{
					ctx.WriteTag(EndTag);
				}
			}
		}

		public T Read(CodedInputStream input)
		{
			ParseContext.Initialize(input, out var ctx);
			try
			{
				return ValueReader(ref ctx);
			}
			finally
			{
				ctx.CopyStateTo(input);
			}
		}

		public T Read(ref ParseContext ctx)
		{
			return ValueReader(ref ctx);
		}

		public int CalculateSizeWithTag(T value)
		{
			if (!IsDefault(value))
			{
				return ValueSizeCalculator(value) + tagSize;
			}
			return 0;
		}

		internal int CalculateUnconditionalSizeWithTag(T value)
		{
			return ValueSizeCalculator(value) + tagSize;
		}

		private bool IsDefault(T value)
		{
			return EqualityComparer.Equals(value, DefaultValue);
		}
	}
	internal sealed class FieldMaskTree
	{
		internal sealed class Node
		{
			public Dictionary<string, Node> Children { get; } = new Dictionary<string, Node>();
		}

		private const char FIELD_PATH_SEPARATOR = '.';

		private readonly Node root = new Node();

		public FieldMaskTree()
		{
		}

		public FieldMaskTree(FieldMask mask)
		{
			MergeFromFieldMask(mask);
		}

		public override string ToString()
		{
			return ToFieldMask().ToString();
		}

		public FieldMaskTree AddFieldPath(string path)
		{
			string[] array = path.Split(new char[1] { '.' });
			if (array.Length == 0)
			{
				return this;
			}
			Node node = root;
			bool flag = false;
			string[] array2 = array;
			foreach (string key in array2)
			{
				if (!flag && node != root && node.Children.Count == 0)
				{
					return this;
				}
				if (!node.Children.TryGetValue(key, out var value))
				{
					flag = true;
					value = new Node();
					node.Children.Add(key, value);
				}
				node = value;
			}
			node.Children.Clear();
			return this;
		}

		public FieldMaskTree MergeFromFieldMask(FieldMask mask)
		{
			foreach (string path in mask.Paths)
			{
				AddFieldPath(path);
			}
			return this;
		}

		public FieldMask ToFieldMask()
		{
			FieldMask fieldMask = new FieldMask();
			if (root.Children.Count != 0)
			{
				List<string> list = new List<string>();
				GetFieldPaths(root, "", list);
				fieldMask.Paths.AddRange(list);
			}
			return fieldMask;
		}

		private void GetFieldPaths(Node node, string path, List<string> paths)
		{
			if (node.Children.Count == 0)
			{
				paths.Add(path);
				return;
			}
			foreach (KeyValuePair<string, Node> child in node.Children)
			{
				string path2 = ((path.Length == 0) ? child.Key : (path + "." + child.Key));
				GetFieldPaths(child.Value, path2, paths);
			}
		}

		public void IntersectFieldPath(string path, FieldMaskTree output)
		{
			if (root.Children.Count == 0)
			{
				return;
			}
			string[] array = path.Split(new char[1] { '.' });
			if (array.Length == 0)
			{
				return;
			}
			Node value = root;
			string[] array2 = array;
			foreach (string key in array2)
			{
				if (value != root && value.Children.Count == 0)
				{
					output.AddFieldPath(path);
					return;
				}
				if (!value.Children.TryGetValue(key, out value))
				{
					return;
				}
			}
			List<string> list = new List<string>();
			GetFieldPaths(value, path, list);
			foreach (string item in list)
			{
				output.AddFieldPath(item);
			}
		}

		public void Merge(IMessage source, IMessage destination, FieldMask.MergeOptions options)
		{
			if (source.Descriptor != destination.Descriptor)
			{
				throw new InvalidProtocolBufferException("Cannot merge messages of different types.");
			}
			if (root.Children.Count != 0)
			{
				Merge(root, "", source, destination, options);
			}
		}

		private void Merge(Node node, string path, IMessage source, IMessage destination, FieldMask.MergeOptions options)
		{
			if (source.Descriptor != destination.Descriptor)
			{
				throw new InvalidProtocolBufferException($"source ({source.Descriptor}) and destination ({destination.Descriptor}) descriptor must be equal");
			}
			MessageDescriptor descriptor = source.Descriptor;
			foreach (KeyValuePair<string, Node> child in node.Children)
			{
				FieldDescriptor fieldDescriptor = descriptor.FindFieldByName(child.Key);
				if (fieldDescriptor == null)
				{
					continue;
				}
				if (child.Value.Children.Count != 0)
				{
					if (fieldDescriptor.IsRepeated || fieldDescriptor.FieldType != FieldType.Message)
					{
						continue;
					}
					object value = fieldDescriptor.Accessor.GetValue(source);
					object obj = fieldDescriptor.Accessor.GetValue(destination);
					if (value != null || obj != null)
					{
						if (obj == null)
						{
							obj = fieldDescriptor.MessageType.Parser.CreateTemplate();
							fieldDescriptor.Accessor.SetValue(destination, obj);
						}
						string path2 = ((path.Length == 0) ? child.Key : (path + "." + child.Key));
						Merge(child.Value, path2, (IMessage)value, (IMessage)obj, options);
					}
					continue;
				}
				if (fieldDescriptor.IsRepeated)
				{
					if (options.ReplaceRepeatedFields)
					{
						fieldDescriptor.Accessor.Clear(destination);
					}
					IList obj2 = (IList)fieldDescriptor.Accessor.GetValue(source);
					IList list = (IList)fieldDescriptor.Accessor.GetValue(destination);
					foreach (object item in obj2)
					{
						list.Add(item);
					}
					continue;
				}
				object value2 = fieldDescriptor.Accessor.GetValue(source);
				if (fieldDescriptor.FieldType == FieldType.Message)
				{
					if (options.ReplaceMessageFields)
					{
						if (value2 == null)
						{
							fieldDescriptor.Accessor.Clear(destination);
						}
						else
						{
							fieldDescriptor.Accessor.SetValue(destination, value2);
						}
					}
					else if (value2 != null)
					{
						ByteString data = ((IMessage)value2).ToByteString();
						IMessage message = (IMessage)fieldDescriptor.Accessor.GetValue(destination);
						if (message != null)
						{
							message.MergeFrom(data);
						}
						else
						{
							fieldDescriptor.Accessor.SetValue(destination, fieldDescriptor.MessageType.Parser.ParseFrom(data));
						}
					}
				}
				else if (value2 != null || !options.ReplacePrimitiveFields)
				{
					fieldDescriptor.Accessor.SetValue(destination, value2);
				}
				else
				{
					fieldDescriptor.Accessor.Clear(destination);
				}
			}
		}
	}
	internal static class FrameworkPortability
	{
		internal static readonly RegexOptions CompiledRegexWhereAvailable = (System.Enum.IsDefined(typeof(RegexOptions), 8) ? RegexOptions.Compiled : RegexOptions.None);
	}
	public interface IBufferMessage : IMessage
	{
		void InternalMergeFrom(ref ParseContext ctx);

		void InternalWriteTo(ref WriteContext ctx);
	}
	public interface ICustomDiagnosticMessage : IMessage
	{
		string ToDiagnosticString();
	}
	public interface IDeepCloneable<T>
	{
		T Clone();
	}
	public interface IExtendableMessage<T> : IMessage<T>, IMessage, IEquatable<T>, IDeepCloneable<T> where T : IExtendableMessage<T>
	{
		TValue GetExtension<TValue>(Extension<T, TValue> extension);

		RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<T, TValue> extension);

		RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<T, TValue> extension);

		void SetExtension<TValue>(Extension<T, TValue> extension, TValue value);

		bool HasExtension<TValue>(Extension<T, TValue> extension);

		void ClearExtension<TValue>(Extension<T, TValue> extension);

		void ClearExtension<TValue>(RepeatedExtension<T, TValue> extension);
	}
	public interface IMessage
	{
		MessageDescriptor Descriptor { get; }

		void MergeFrom(CodedInputStream input);

		void WriteTo(CodedOutputStream output);

		int CalculateSize();
	}
	public interface IMessage<T> : IMessage, IEquatable<T>, IDeepCloneable<T> where T : IMessage<T>
	{
		void MergeFrom(T message);
	}
	public sealed class InvalidJsonException : IOException
	{
		internal InvalidJsonException(string message)
			: base(message)
		{
		}
	}
	public sealed class InvalidProtocolBufferException : IOException
	{
		internal InvalidProtocolBufferException(string message)
			: base(message)
		{
		}

		internal InvalidProtocolBufferException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		internal static InvalidProtocolBufferException MoreDataAvailable()
		{
			return new InvalidProtocolBufferException("Completed reading a message while more data was available in the stream.");
		}

		internal static InvalidProtocolBufferException TruncatedMessage()
		{
			return new InvalidProtocolBufferException("While parsing a protocol message, the input ended unexpectedly in the middle of a field.  This could mean either that the input has been truncated or that an embedded message misreported its own length.");
		}

		internal static InvalidProtocolBufferException NegativeSize()
		{
			return new InvalidProtocolBufferException("CodedInputStream encountered an embedded string or message which claimed to have negative size.");
		}

		internal static InvalidProtocolBufferException MalformedVarint()
		{
			return new InvalidProtocolBufferException("CodedInputStream encountered a malformed varint.");
		}

		internal static InvalidProtocolBufferException InvalidTag()
		{
			return new InvalidProtocolBufferException("Protocol message contained an invalid tag (zero).");
		}

		internal static InvalidProtocolBufferException InvalidWireType()
		{
			return new InvalidProtocolBufferException("Protocol message contained a tag with an invalid wire type.");
		}

		internal static InvalidProtocolBufferException InvalidBase64(Exception innerException)
		{
			return new InvalidProtocolBufferException("Invalid base64 data", innerException);
		}

		internal static InvalidProtocolBufferException InvalidEndTag()
		{
			return new InvalidProtocolBufferException("Protocol message end-group tag did not match expected tag.");
		}

		internal static InvalidProtocolBufferException RecursionLimitExceeded()
		{
			return new InvalidProtocolBufferException("Protocol message had too many levels of nesting.  May be malicious.  Use CodedInputStream.SetRecursionLimit() to increase the depth limit.");
		}

		internal static InvalidProtocolBufferException JsonRecursionLimitExceeded()
		{
			return new InvalidProtocolBufferException("Protocol message had too many levels of nesting.  May be malicious.  Use JsonParser.Settings to increase the depth limit.");
		}

		internal static InvalidProtocolBufferException SizeLimitExceeded()
		{
			return new InvalidProtocolBufferException("Protocol message was too large.  May be malicious.  Use CodedInputStream.SetSizeLimit() to increase the size limit.");
		}

		internal static InvalidProtocolBufferException InvalidMessageStreamTag()
		{
			return new InvalidProtocolBufferException("Stream of protocol messages had invalid tag. Expected tag is length-delimited field 1.");
		}

		internal static InvalidProtocolBufferException MissingFields()
		{
			return new InvalidProtocolBufferException("Message was missing required fields");
		}
	}
	public sealed class JsonFormatter
	{
		public sealed class Settings
		{
			public static Settings Default { get; }

			public bool FormatDefaultValues { get; }

			public TypeRegistry TypeRegistry { get; }

			public bool FormatEnumsAsIntegers { get; }

			public bool PreserveProtoFieldNames { get; }

			static Settings()
			{
				Default = new Settings(formatDefaultValues: false);
			}

			public Settings(bool formatDefaultValues)
				: this(formatDefaultValues, TypeRegistry.Empty)
			{
			}

			public Settings(bool formatDefaultValues, TypeRegistry typeRegistry)
				: this(formatDefaultValues, typeRegistry, formatEnumsAsIntegers: false, preserveProtoFieldNames: false)
			{
			}

			private Settings(bool formatDefaultValues, TypeRegistry typeRegistry, bool formatEnumsAsIntegers, bool preserveProtoFieldNames)
			{
				FormatDefaultValues = formatDefaultValues;
				TypeRegistry = typeRegistry ?? TypeRegistry.Empty;
				FormatEnumsAsIntegers = formatEnumsAsIntegers;
				PreserveProtoFieldNames = preserveProtoFieldNames;
			}

			public Settings WithFormatDefaultValues(bool formatDefaultValues)
			{
				return new Settings(formatDefaultValues, TypeRegistry, FormatEnumsAsIntegers, PreserveProtoFieldNames);
			}

			public Settings WithTypeRegistry(TypeRegistry typeRegistry)
			{
				return new Settings(FormatDefaultValues, typeRegistry, FormatEnumsAsIntegers, PreserveProtoFieldNames);
			}

			public Settings WithFormatEnumsAsIntegers(bool formatEnumsAsIntegers)
			{
				return new Settings(FormatDefaultValues, TypeRegistry, formatEnumsAsIntegers, PreserveProtoFieldNames);
			}

			public Settings WithPreserveProtoFieldNames(bool preserveProtoFieldNames)
			{
				return new Settings(FormatDefaultValues, TypeRegistry, FormatEnumsAsIntegers, preserveProtoFieldNames);
			}
		}

		private static class OriginalEnumValueHelper
		{
			private static readonly Dictionary<System.Type, Dictionary<object, string>> dictionaries = new Dictionary<System.Type, Dictionary<object, string>>();

			[UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "The field for the value must still be present. It will be returned by reflection, will be in this collection, and its name can be resolved.")]
			internal static string GetOriginalName(object value)
			{
				System.Type type = value.GetType();
				Dictionary<object, string> value2;
				lock (dictionaries)
				{
					if (!dictionaries.TryGetValue(type, out value2))
					{
						value2 = GetNameMapping(type);
						dictionaries[type] = value2;
					}
				}
				value2.TryGetValue(value, out var value3);
				return value3;
			}

			private static Dictionary<object, string> GetNameMapping([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields)] System.Type enumType)
			{
				return (from f in enumType.GetTypeInfo().DeclaredFields
					where f.IsStatic
					where f.GetCustomAttributes<OriginalNameAttribute>().FirstOrDefault()?.PreferredAlias ?? true
					select f).ToDictionary((FieldInfo f) => f.GetValue(null), (FieldInfo f) => f.GetCustomAttributes<OriginalNameAttribute>().FirstOrDefault()?.Name ?? f.Name);
			}
		}

		internal const string AnyTypeUrlField = "@type";

		internal const string AnyDiagnosticValueField = "@value";

		internal const string AnyWellKnownTypeValueField = "value";

		private const string TypeUrlPrefix = "type.googleapis.com";

		private const string NameValueSeparator = ": ";

		private const string PropertySeparator = ", ";

		private static readonly JsonFormatter diagnosticFormatter;

		private static readonly string[] CommonRepresentations;

		private readonly Settings settings;

		private const string Hex = "0123456789abcdef";

		public static JsonFormatter Default { get; }

		private bool DiagnosticOnly => this == diagnosticFormatter;

		static JsonFormatter()
		{
			Default = new JsonFormatter(Settings.Default);
			diagnosticFormatter = new JsonFormatter(Settings.Default);
			CommonRepresentations = new string[160]
			{
				"\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006", "\\u0007", "\\b", "\\t",
				"\\n", "\\u000b", "\\f", "\\r", "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013",
				"\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b", "\\u001c", "\\u001d",
				"\\u001e", "\\u001f", "", "", "\\\"", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"\\u003c", "", "\\u003e", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "\\\\", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "", "", "",
				"", "", "", "", "", "", "", "\\u007f", "\\u0080", "\\u0081",
				"\\u0082", "\\u0083", "\\u0084", "\\u0085", "\\u0086", "\\u0087", "\\u0088", "\\u0089", "\\u008a", "\\u008b",
				"\\u008c", "\\u008d", "\\u008e", "\\u008f", "\\u0090", "\\u0091", "\\u0092", "\\u0093", "\\u0094", "\\u0095",
				"\\u0096", "\\u0097", "\\u0098", "\\u0099", "\\u009a", "\\u009b", "\\u009c", "\\u009d", "\\u009e", "\\u009f"
			};
			for (int i = 0; i < CommonRepresentations.Length; i++)
			{
				if (CommonRepresentations[i] == "")
				{
					CommonRepresentations[i] = ((char)i).ToString();
				}
			}
		}

		public JsonFormatter(Settings settings)
		{
			this.settings = ProtoPreconditions.CheckNotNull(settings, "settings");
		}

		public string Format(IMessage message)
		{
			StringWriter stringWriter = new StringWriter();
			Format(message, stringWriter);
			return stringWriter.ToString();
		}

		public void Format(IMessage message, TextWriter writer)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(writer, "writer");
			if (message.Descriptor.IsWellKnownType)
			{
				WriteWellKnownTypeValue(writer, message.Descriptor, message);
			}
			else
			{
				WriteMessage(writer, message);
			}
		}

		public static string ToDiagnosticString(IMessage message)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			return diagnosticFormatter.Format(message);
		}

		private void WriteMessage(TextWriter writer, IMessage message)
		{
			if (message == null)
			{
				WriteNull(writer);
				return;
			}
			if (DiagnosticOnly && message is ICustomDiagnosticMessage customDiagnosticMessage)
			{
				writer.Write(customDiagnosticMessage.ToDiagnosticString());
				return;
			}
			writer.Write("{ ");
			bool flag = WriteMessageFields(writer, message, assumeFirstFieldWritten: false);
			writer.Write(flag ? " }" : "}");
		}

		private bool WriteMessageFields(TextWriter writer, IMessage message, bool assumeFirstFieldWritten)
		{
			MessageDescriptor.FieldCollection fields = message.Descriptor.Fields;
			bool flag = !assumeFirstFieldWritten;
			foreach (FieldDescriptor item in fields.InFieldNumberOrder())
			{
				IFieldAccessor accessor = item.Accessor;
				object value = accessor.GetValue(message);
				if (ShouldFormatFieldValue(message, item, value))
				{
					if (!flag)
					{
						writer.Write(", ");
					}
					if (settings.PreserveProtoFieldNames)
					{
						WriteString(writer, accessor.Descriptor.Name);
					}
					else
					{
						WriteString(writer, accessor.Descriptor.JsonName);
					}
					writer.Write(": ");
					WriteValue(writer, value);
					flag = false;
				}
			}
			return !flag;
		}

		private bool ShouldFormatFieldValue(IMessage message, FieldDescriptor field, object value)
		{
			if (!field.HasPresence)
			{
				if (!settings.FormatDefaultValues)
				{
					return !IsDefaultValue(field, value);
				}
				return true;
			}
			return field.Accessor.HasValue(message);
		}

		internal static string ToJsonName(string name)
		{
			StringBuilder stringBuilder = new StringBuilder(name.Length);
			bool flag = false;
			foreach (char c in name)
			{
				if (c == '_')
				{
					flag = true;
				}
				else if (flag)
				{
					stringBuilder.Append(char.ToUpperInvariant(c));
					flag = false;
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		internal static string FromJsonName(string name)
		{
			StringBuilder stringBuilder = new StringBuilder(name.Length);
			foreach (char c in name)
			{
				if (char.IsUpper(c))
				{
					stringBuilder.Append('_');
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		private static void WriteNull(TextWriter writer)
		{
			writer.Write("null");
		}

		private static bool IsDefaultValue(FieldDescriptor descriptor, object value)
		{
			if (descriptor.IsMap)
			{
				return ((IDictionary)value).Count == 0;
			}
			if (descriptor.IsRepeated)
			{
				return ((IList)value).Count == 0;
			}
			switch (descriptor.FieldType)
			{
			case FieldType.Bool:
				return !(bool)value;
			case FieldType.Bytes:
				return (ByteString)value == ByteString.Empty;
			case FieldType.String:
				return (string)value == "";
			case FieldType.Double:
				return (double)value == 0.0;
			case FieldType.Int32:
			case FieldType.SFixed32:
			case FieldType.SInt32:
			case FieldType.Enum:
				return (int)value == 0;
			case FieldType.Fixed32:
			case FieldType.UInt32:
				return (uint)value == 0;
			case FieldType.UInt64:
			case FieldType.Fixed64:
				return (ulong)value == 0;
			case FieldType.Int64:
			case FieldType.SFixed64:
			case FieldType.SInt64:
				return (long)value == 0;
			case FieldType.Float:
				return (float)value == 0f;
			case FieldType.Group:
			case FieldType.Message:
				return value == null;
			default:
				throw new ArgumentException("Invalid field type");
			}
		}

		public void WriteValue(TextWriter writer, object value)
		{
			if (value == null || value is NullValue)
			{
				WriteNull(writer);
			}
			else if (value is bool)
			{
				writer.Write(((bool)value) ? "true" : "false");
			}
			else if (value is ByteString)
			{
				writer.Write('"');
				writer.Write(((ByteString)value).ToBase64());
				writer.Write('"');
			}
			else if (value is string)
			{
				WriteString(writer, (string)value);
			}
			else if (value is IDictionary)
			{
				WriteDictionary(writer, (IDictionary)value);
			}
			else if (value is IList)
			{
				WriteList(writer, (IList)value);
			}
			else if (value is int || value is uint)
			{
				IFormattable formattable = (IFormattable)value;
				writer.Write(formattable.ToString("d", CultureInfo.InvariantCulture));
			}
			else if (value is long || value is ulong)
			{
				writer.Write('"');
				IFormattable formattable2 = (IFormattable)value;
				writer.Write(formattable2.ToString("d", CultureInfo.InvariantCulture));
				writer.Write('"');
			}
			else if (value is System.Enum)
			{
				if (settings.FormatEnumsAsIntegers)
				{
					WriteValue(writer, (int)value);
					return;
				}
				string originalName = OriginalEnumValueHelper.GetOriginalName(value);
				if (originalName != null)
				{
					WriteString(writer, originalName);
				}
				else
				{
					WriteValue(writer, (int)value);
				}
			}
			else if (value is float || value is double)
			{
				string text = ((IFormattable)value).ToString("r", CultureInfo.InvariantCulture);
				switch (text)
				{
				case "NaN":
				case "Infinity":
				case "-Infinity":
					writer.Write('"');
					writer.Write(text);
					writer.Write('"');
					break;
				default:
					writer.Write(text);
					break;
				}
			}
			else
			{
				if (!(value is IMessage))
				{
					throw new ArgumentException("Unable to format value of type " + value.GetType());
				}
				Format((IMessage)value, writer);
			}
		}

		private void WriteWellKnownTypeValue(TextWriter writer, MessageDescriptor descriptor, object value)
		{
			if (value == null)
			{
				WriteNull(writer);
			}
			else if (descriptor.IsWrapperType)
			{
				if (value is IMessage)
				{
					IMessage message = (IMessage)value;
					value = message.Descriptor.Fields[1].Accessor.GetValue(message);
				}
				WriteValue(writer, value);
			}
			else if (descriptor.FullName == Timestamp.Descriptor.FullName)
			{
				WriteTimestamp(writer, (IMessage)value);
			}
			else if (descriptor.FullName == Duration.Descriptor.FullName)
			{
				WriteDuration(writer, (IMessage)value);
			}
			else if (descriptor.FullName == FieldMask.Descriptor.FullName)
			{
				WriteFieldMask(writer, (IMessage)value);
			}
			else if (descriptor.FullName == Struct.Descriptor.FullName)
			{
				WriteStruct(writer, (IMessage)value);
			}
			else if (descriptor.FullName == ListValue.Descriptor.FullName)
			{
				IFieldAccessor accessor = descriptor.Fields[1].Accessor;
				WriteList(writer, (IList)accessor.GetValue((IMessage)value));
			}
			else if (descriptor.FullName == Value.Descriptor.FullName)
			{
				WriteStructFieldValue(writer, (IMessage)value);
			}
			else if (descriptor.FullName == Any.Descriptor.FullName)
			{
				WriteAny(writer, (IMessage)value);
			}
			else
			{
				WriteMessage(writer, (IMessage)value);
			}
		}

		private void WriteTimestamp(TextWriter writer, IMessage value)
		{
			int nanoseconds = (int)value.Descriptor.Fields[2].Accessor.GetValue(value);
			long seconds = (long)value.Descriptor.Fields[1].Accessor.GetValue(value);
			writer.Write(Timestamp.ToJson(seconds, nanoseconds, DiagnosticOnly));
		}

		private void WriteDuration(TextWriter writer, IMessage value)
		{
			int nanoseconds = (int)value.Descriptor.Fields[2].Accessor.GetValue(value);
			long seconds = (long)value.Descriptor.Fields[1].Accessor.GetValue(value);
			writer.Write(Duration.ToJson(seconds, nanoseconds, DiagnosticOnly));
		}

		private void WriteFieldMask(TextWriter writer, IMessage value)
		{
			IList<string> paths = (IList<string>)value.Descriptor.Fields[1].Accessor.GetValue(value);
			writer.Write(FieldMask.ToJson(paths, DiagnosticOnly));
		}

		private void WriteAny(TextWriter writer, IMessage value)
		{
			if (DiagnosticOnly)
			{
				WriteDiagnosticOnlyAny(writer, value);
				return;
			}
			string text = (string)value.Descriptor.Fields[1].Accessor.GetValue(value);
			ByteString data = (ByteString)value.Descriptor.Fields[2].Accessor.GetValue(value);
			string typeName = Any.GetTypeName(text);
			MessageDescriptor messageDescriptor = settings.TypeRegistry.Find(typeName);
			if (messageDescriptor == null)
			{
				throw new InvalidOperationException("Type registry has no descriptor for type name '" + typeName + "'");
			}
			IMessage message = messageDescriptor.Parser.ParseFrom(data);
			writer.Write("{ ");
			WriteString(writer, "@type");
			writer.Write(": ");
			WriteString(writer, text);
			if (messageDescriptor.IsWellKnownType)
			{
				writer.Write(", ");
				WriteString(writer, "value");
				writer.Write(": ");
				WriteWellKnownTypeValue(writer, messageDescriptor, message);
			}
			else
			{
				WriteMessageFields(writer, message, assumeFirstFieldWritten: true);
			}
			writer.Write(" }");
		}

		private void WriteDiagnosticOnlyAny(TextWriter writer, IMessage value)
		{
			string text = (string)value.Descriptor.Fields[1].Accessor.GetValue(value);
			ByteString byteString = (ByteString)value.Descriptor.Fields[2].Accessor.GetValue(value);
			writer.Write("{ ");
			WriteString(writer, "@type");
			writer.Write(": ");
			WriteString(writer, text);
			writer.Write(", ");
			WriteString(writer, "@value");
			writer.Write(": ");
			writer.Write('"');
			writer.Write(byteString.ToBase64());
			writer.Write('"');
			writer.Write(" }");
		}

		private void WriteStruct(TextWriter writer, IMessage message)
		{
			writer.Write("{ ");
			IDictionary obj = (IDictionary)message.Descriptor.Fields[1].Accessor.GetValue(message);
			bool flag = true;
			foreach (DictionaryEntry item in obj)
			{
				string text = (string)item.Key;
				IMessage message2 = (IMessage)item.Value;
				if (string.IsNullOrEmpty(text) || message2 == null)
				{
					throw new InvalidOperationException("Struct fields cannot have an empty key or a null value.");
				}
				if (!flag)
				{
					writer.Write(", ");
				}
				WriteString(writer, text);
				writer.Write(": ");
				WriteStructFieldValue(writer, message2);
				flag = false;
			}
			writer.Write(flag ? "}" : " }");
		}

		private void WriteStructFieldValue(TextWriter writer, IMessage message)
		{
			FieldDescriptor caseFieldDescriptor = message.Descriptor.Oneofs[0].Accessor.GetCaseFieldDescriptor(message);
			if (caseFieldDescriptor == null)
			{
				throw new InvalidOperationException("Value message must contain a value for the oneof.");
			}
			object value = caseFieldDescriptor.Accessor.GetValue(message);
			switch (caseFieldDescriptor.FieldNumber)
			{
			case 2:
			case 3:
			case 4:
				WriteValue(writer, value);
				break;
			case 5:
			case 6:
			{
				IMessage message2 = (IMessage)caseFieldDescriptor.Accessor.GetValue(message);
				WriteWellKnownTypeValue(writer, message2.Descriptor, message2);
				break;
			}
			case 1:
				WriteNull(writer);
				break;
			default:
				throw new InvalidOperationException("Unexpected case in struct field: " + caseFieldDescriptor.FieldNumber);
			}
		}

		internal void WriteList(TextWriter writer, IList list)
		{
			writer.Write("[ ");
			bool flag = true;
			foreach (object item in list)
			{
				if (!flag)
				{
					writer.Write(", ");
				}
				WriteValue(writer, item);
				flag = false;
			}
			writer.Write(flag ? "]" : " ]");
		}

		internal void WriteDictionary(TextWriter writer, IDictionary dictionary)
		{
			writer.Write("{ ");
			bool flag = true;
			foreach (DictionaryEntry item in dictionary)
			{
				if (!flag)
				{
					writer.Write(", ");
				}
				string text;
				if (item.Key is string)
				{
					text = (string)item.Key;
				}
				else if (item.Key is bool)
				{
					text = (((bool)item.Key) ? "true" : "false");
				}
				else
				{
					if (!(item.Key is int) && !((item.Key is uint) | (item.Key is long)) && !(item.Key is ulong))
					{
						if (item.Key == null)
						{
							throw new ArgumentException("Dictionary has entry with null key");
						}
						throw new ArgumentException("Unhandled dictionary key type: " + item.Key.GetType());
					}
					text = ((IFormattable)item.Key).ToString("d", CultureInfo.InvariantCulture);
				}
				WriteString(writer, text);
				writer.Write(": ");
				WriteValue(writer, item.Value);
				flag = false;
			}
			writer.Write(flag ? "}" : " }");
		}

		internal static void WriteString(TextWriter writer, string text)
		{
			writer.Write('"');
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c < '\u00a0')
				{
					writer.Write(CommonRepresentations[(uint)c]);
					continue;
				}
				if (char.IsHighSurrogate(c))
				{
					i++;
					if (i == text.Length || !char.IsLowSurrogate(text[i]))
					{
						throw new ArgumentException("String contains low surrogate not followed by high surrogate");
					}
					HexEncodeUtf16CodeUnit(writer, c);
					HexEncodeUtf16CodeUnit(writer, text[i]);
					continue;
				}
				if (char.IsLowSurrogate(c))
				{
					throw new ArgumentException("String contains high surrogate not preceded by low surrogate");
				}
				switch (c)
				{
				case 173u:
				case 1757u:
				case 1807u:
				case 6068u:
				case 6069u:
				case 65279u:
				case 65529u:
				case 65530u:
				case 65531u:
					HexEncodeUtf16CodeUnit(writer, c);
					continue;
				}
				if ((c >= '\u0600' && c <= '\u0603') || (c >= '\u200b' && c <= '\u200f') || (c >= '\u2028' && c <= '\u202e') || (c >= '\u2060' && c <= '\u2064') || (c >= '\u206a' && c <= '\u206f'))
				{
					HexEncodeUtf16CodeUnit(writer, c);
				}
				else
				{
					writer.Write(c);
				}
			}
			writer.Write('"');
		}

		private static void HexEncodeUtf16CodeUnit(TextWriter writer, char c)
		{
			writer.Write("\\u");
			writer.Write("0123456789abcdef"[((int)c >> 12) & 0xF]);
			writer.Write("0123456789abcdef"[((int)c >> 8) & 0xF]);
			writer.Write("0123456789abcdef"[((int)c >> 4) & 0xF]);
			writer.Write("0123456789abcdef"[c & 0xF]);
		}
	}
	public sealed class JsonParser
	{
		public sealed class Settings
		{
			public static Settings Default { get; }

			public int RecursionLimit { get; }

			public TypeRegistry TypeRegistry { get; }

			public bool IgnoreUnknownFields { get; }

			static Settings()
			{
				Default = new Settings(100);
			}

			private Settings(int recursionLimit, TypeRegistry typeRegistry, bool ignoreUnknownFields)
			{
				RecursionLimit = recursionLimit;
				TypeRegistry = ProtoPreconditions.CheckNotNull(typeRegistry, "typeRegistry");
				IgnoreUnknownFields = ignoreUnknownFields;
			}

			public Settings(int recursionLimit)
				: this(recursionLimit, TypeRegistry.Empty)
			{
			}

			public Settings(int recursionLimit, TypeRegistry typeRegistry)
				: this(recursionLimit, typeRegistry, ignoreUnknownFields: false)
			{
			}

			public Settings WithIgnoreUnknownFields(bool ignoreUnknownFields)
			{
				return new Settings(RecursionLimit, TypeRegistry, ignoreUnknownFields);
			}

			public Settings WithRecursionLimit(int recursionLimit)
			{
				return new Settings(recursionLimit, TypeRegistry, IgnoreUnknownFields);
			}

			public Settings WithTypeRegistry(TypeRegistry typeRegistry)
			{
				return new Settings(RecursionLimit, ProtoPreconditions.CheckNotNull(typeRegistry, "typeRegistry"), IgnoreUnknownFields);
			}
		}

		private static readonly Regex TimestampRegex = new Regex("^(?<datetime>[0-9]{4}-[01][0-9]-[0-3][0-9]T[012][0-9]:[0-5][0-9]:[0-5][0-9])(?<subseconds>\\.[0-9]{1,9})?(?<offset>(Z|[+-][0-1][0-9]:[0-5][0-9]))$", FrameworkPortability.CompiledRegexWhereAvailable);

		private static readonly Regex DurationRegex = new Regex("^(?<sign>-)?(?<int>[0-9]{1,12})(?<subseconds>\\.[0-9]{1,9})?s$", FrameworkPortability.CompiledRegexWhereAvailable);

		private static readonly int[] SubsecondScalingFactors = new int[11]
		{
			0, 100000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10,
			1
		};

		private static readonly char[] FieldMaskPathSeparators = new char[1] { ',' };

		private static readonly EnumDescriptor NullValueDescriptor = StructReflection.Descriptor.EnumTypes.Single((EnumDescriptor ed) => ed.ClrType == typeof(NullValue));

		private static readonly JsonParser defaultInstance = new JsonParser(Settings.Default);

		private static readonly Dictionary<string, Action<JsonParser, IMessage, JsonTokenizer>> WellKnownTypeHandlers = new Dictionary<string, Action<JsonParser, IMessage, JsonTokenizer>>
		{
			{
				Timestamp.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					MergeTimestamp(message, tokenizer.Next());
				}
			},
			{
				Duration.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					MergeDuration(message, tokenizer.Next());
				}
			},
			{
				Value.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					parser.MergeStructValue(message, tokenizer);
				}
			},
			{
				ListValue.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					parser.MergeRepeatedField(message, message.Descriptor.Fields[1], tokenizer);
				}
			},
			{
				Struct.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					parser.MergeStruct(message, tokenizer);
				}
			},
			{
				Any.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					parser.MergeAny(message, tokenizer);
				}
			},
			{
				FieldMask.Descriptor.FullName,
				delegate(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
				{
					MergeFieldMask(message, tokenizer.Next());
				}
			},
			{
				Int32Value.Descriptor.FullName,
				MergeWrapperField
			},
			{
				Int64Value.Descriptor.FullName,
				MergeWrapperField
			},
			{
				UInt32Value.Descriptor.FullName,
				MergeWrapperField
			},
			{
				UInt64Value.Descriptor.FullName,
				MergeWrapperField
			},
			{
				FloatValue.Descriptor.FullName,
				MergeWrapperField
			},
			{
				DoubleValue.Descriptor.FullName,
				MergeWrapperField
			},
			{
				BytesValue.Descriptor.FullName,
				MergeWrapperField
			},
			{
				StringValue.Descriptor.FullName,
				MergeWrapperField
			},
			{
				BoolValue.Descriptor.FullName,
				MergeWrapperField
			}
		};

		private readonly Settings settings;

		public static JsonParser Default => defaultInstance;

		private static void MergeWrapperField(JsonParser parser, IMessage message, JsonTokenizer tokenizer)
		{
			parser.MergeField(message, message.Descriptor.Fields[1], tokenizer);
		}

		public JsonParser(Settings settings)
		{
			this.settings = ProtoPreconditions.CheckNotNull(settings, "settings");
		}

		internal void Merge(IMessage message, string json)
		{
			Merge(message, new StringReader(json));
		}

		internal void Merge(IMessage message, TextReader jsonReader)
		{
			JsonTokenizer jsonTokenizer = JsonTokenizer.FromTextReader(jsonReader);
			Merge(message, jsonTokenizer);
			if (jsonTokenizer.Next() != JsonToken.EndDocument)
			{
				throw new InvalidProtocolBufferException("Expected end of JSON after object");
			}
		}

		private void Merge(IMessage message, JsonTokenizer tokenizer)
		{
			if (tokenizer.ObjectDepth > settings.RecursionLimit)
			{
				throw InvalidProtocolBufferException.JsonRecursionLimitExceeded();
			}
			if (message.Descriptor.IsWellKnownType && WellKnownTypeHandlers.TryGetValue(message.Descriptor.FullName, out var value))
			{
				value(this, message, tokenizer);
				return;
			}
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StartObject)
			{
				throw new InvalidProtocolBufferException("Expected an object");
			}
			IDictionary<string, FieldDescriptor> dictionary = message.Descriptor.Fields.ByJsonName();
			HashSet<OneofDescriptor> hashSet = null;
			string stringValue;
			while (true)
			{
				jsonToken = tokenizer.Next();
				if (jsonToken.Type == JsonToken.TokenType.EndObject)
				{
					return;
				}
				if (jsonToken.Type != JsonToken.TokenType.Name)
				{
					throw new InvalidOperationException("Unexpected token type " + jsonToken.Type);
				}
				stringValue = jsonToken.StringValue;
				if (dictionary.TryGetValue(stringValue, out var value2))
				{
					if (value2.ContainingOneof != null)
					{
						if (hashSet == null)
						{
							hashSet = new HashSet<OneofDescriptor>();
						}
						if (!hashSet.Add(value2.ContainingOneof))
						{
							throw new InvalidProtocolBufferException("Multiple values specified for oneof " + value2.ContainingOneof.Name);
						}
					}
					MergeField(message, value2, tokenizer);
				}
				else
				{
					if (!settings.IgnoreUnknownFields)
					{
						break;
					}
					tokenizer.SkipValue();
				}
			}
			throw new InvalidProtocolBufferException("Unknown field: " + stringValue);
		}

		private void MergeField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type == JsonToken.TokenType.Null && (field.IsMap || field.IsRepeated || (!IsGoogleProtobufValueField(field) && !IsGoogleProtobufNullValueField(field))))
			{
				field.Accessor.Clear(message);
				return;
			}
			tokenizer.PushBack(jsonToken);
			if (field.IsMap)
			{
				MergeMapField(message, field, tokenizer);
				return;
			}
			if (field.IsRepeated)
			{
				MergeRepeatedField(message, field, tokenizer);
				return;
			}
			object value = ParseSingleValue(field, tokenizer);
			field.Accessor.SetValue(message, value);
		}

		private void MergeRepeatedField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StartArray)
			{
				throw new InvalidProtocolBufferException("Repeated field value was not an array. Token type: " + jsonToken.Type);
			}
			IList list = (IList)field.Accessor.GetValue(message);
			while (true)
			{
				jsonToken = tokenizer.Next();
				if (jsonToken.Type == JsonToken.TokenType.EndArray)
				{
					return;
				}
				tokenizer.PushBack(jsonToken);
				object obj = ParseSingleValue(field, tokenizer);
				if (obj == null)
				{
					break;
				}
				list.Add(obj);
			}
			throw new InvalidProtocolBufferException("Repeated field elements cannot be null");
		}

		private void MergeMapField(IMessage message, FieldDescriptor field, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StartObject)
			{
				throw new InvalidProtocolBufferException("Expected an object to populate a map");
			}
			MessageDescriptor messageType = field.MessageType;
			FieldDescriptor fieldDescriptor = messageType.FindFieldByNumber(1);
			FieldDescriptor fieldDescriptor2 = messageType.FindFieldByNumber(2);
			if (fieldDescriptor == null || fieldDescriptor2 == null)
			{
				throw new InvalidProtocolBufferException("Invalid map field: " + field.FullName);
			}
			IDictionary dictionary = (IDictionary)field.Accessor.GetValue(message);
			while (true)
			{
				jsonToken = tokenizer.Next();
				if (jsonToken.Type == JsonToken.TokenType.EndObject)
				{
					return;
				}
				object key = ParseMapKey(fieldDescriptor, jsonToken.StringValue);
				object obj = ParseSingleValue(fieldDescriptor2, tokenizer);
				if (obj == null)
				{
					break;
				}
				dictionary[key] = obj;
			}
			throw new InvalidProtocolBufferException("Map values must not be null");
		}

		private static bool IsGoogleProtobufValueField(FieldDescriptor field)
		{
			if (field.FieldType == FieldType.Message)
			{
				return field.MessageType.FullName == Value.Descriptor.FullName;
			}
			return false;
		}

		private static bool IsGoogleProtobufNullValueField(FieldDescriptor field)
		{
			if (field.FieldType == FieldType.Enum)
			{
				return field.EnumType.FullName == NullValueDescriptor.FullName;
			}
			return false;
		}

		private object ParseSingleValue(FieldDescriptor field, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type == JsonToken.TokenType.Null)
			{
				if (IsGoogleProtobufValueField(field))
				{
					return Value.ForNull();
				}
				if (IsGoogleProtobufNullValueField(field))
				{
					return NullValue.NullValue;
				}
				return null;
			}
			FieldType fieldType = field.FieldType;
			if (fieldType == FieldType.Message)
			{
				if (!field.MessageType.IsWrapperType)
				{
					tokenizer.PushBack(jsonToken);
					IMessage message = NewMessageForField(field);
					Merge(message, tokenizer);
					return message;
				}
				field = field.MessageType.Fields[1];
				fieldType = field.FieldType;
			}
			switch (jsonToken.Type)
			{
			case JsonToken.TokenType.False:
			case JsonToken.TokenType.True:
				if (fieldType == FieldType.Bool)
				{
					return jsonToken.Type == JsonToken.TokenType.True;
				}
				break;
			case JsonToken.TokenType.StringValue:
				return ParseSingleStringValue(field, jsonToken.StringValue);
			case JsonToken.TokenType.Number:
				return ParseSingleNumberValue(field, jsonToken);
			case JsonToken.TokenType.Null:
				throw new NotImplementedException("Haven't worked out what to do for null yet");
			}
			throw new InvalidProtocolBufferException("Unsupported JSON token type " + jsonToken.Type.ToString() + " for field type " + fieldType);
		}

		public T Parse<T>(string json) where T : IMessage, new()
		{
			ProtoPreconditions.CheckNotNull(json, "json");
			return Parse<T>(new StringReader(json));
		}

		public T Parse<T>(TextReader jsonReader) where T : IMessage, new()
		{
			ProtoPreconditions.CheckNotNull(jsonReader, "jsonReader");
			T val = new T();
			Merge(val, jsonReader);
			return val;
		}

		public IMessage Parse(string json, MessageDescriptor descriptor)
		{
			ProtoPreconditions.CheckNotNull(json, "json");
			ProtoPreconditions.CheckNotNull(descriptor, "descriptor");
			return Parse(new StringReader(json), descriptor);
		}

		public IMessage Parse(TextReader jsonReader, MessageDescriptor descriptor)
		{
			ProtoPreconditions.CheckNotNull(jsonReader, "jsonReader");
			ProtoPreconditions.CheckNotNull(descriptor, "descriptor");
			IMessage message = descriptor.Parser.CreateTemplate();
			Merge(message, jsonReader);
			return message;
		}

		private void MergeStructValue(IMessage message, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			MessageDescriptor.FieldCollection fields = message.Descriptor.Fields;
			switch (jsonToken.Type)
			{
			case JsonToken.TokenType.Null:
				fields[1].Accessor.SetValue(message, 0);
				break;
			case JsonToken.TokenType.StringValue:
				fields[3].Accessor.SetValue(message, jsonToken.StringValue);
				break;
			case JsonToken.TokenType.Number:
				fields[2].Accessor.SetValue(message, jsonToken.NumberValue);
				break;
			case JsonToken.TokenType.False:
			case JsonToken.TokenType.True:
				fields[4].Accessor.SetValue(message, jsonToken.Type == JsonToken.TokenType.True);
				break;
			case JsonToken.TokenType.StartObject:
			{
				FieldDescriptor fieldDescriptor2 = fields[5];
				IMessage message3 = NewMessageForField(fieldDescriptor2);
				tokenizer.PushBack(jsonToken);
				Merge(message3, tokenizer);
				fieldDescriptor2.Accessor.SetValue(message, message3);
				break;
			}
			case JsonToken.TokenType.StartArray:
			{
				FieldDescriptor fieldDescriptor = fields[6];
				IMessage message2 = NewMessageForField(fieldDescriptor);
				tokenizer.PushBack(jsonToken);
				Merge(message2, tokenizer);
				fieldDescriptor.Accessor.SetValue(message, message2);
				break;
			}
			default:
				throw new InvalidOperationException("Unexpected token type: " + jsonToken.Type);
			}
		}

		private void MergeStruct(IMessage message, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StartObject)
			{
				throw new InvalidProtocolBufferException("Expected object value for Struct");
			}
			tokenizer.PushBack(jsonToken);
			FieldDescriptor field = message.Descriptor.Fields[1];
			MergeMapField(message, field, tokenizer);
		}

		private void MergeAny(IMessage message, JsonTokenizer tokenizer)
		{
			List<JsonToken> list = new List<JsonToken>();
			JsonToken jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StartObject)
			{
				throw new InvalidProtocolBufferException("Expected object value for Any");
			}
			int objectDepth = tokenizer.ObjectDepth;
			while (jsonToken.Type != JsonToken.TokenType.Name || jsonToken.StringValue != "@type" || tokenizer.ObjectDepth != objectDepth)
			{
				list.Add(jsonToken);
				jsonToken = tokenizer.Next();
				if (tokenizer.ObjectDepth < objectDepth)
				{
					throw new InvalidProtocolBufferException("Any message with no @type");
				}
			}
			jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.StringValue)
			{
				throw new InvalidProtocolBufferException("Expected string value for Any.@type");
			}
			string stringValue = jsonToken.StringValue;
			string typeName = Any.GetTypeName(stringValue);
			MessageDescriptor obj = settings.TypeRegistry.Find(typeName) ?? throw new InvalidOperationException("Type registry has no descriptor for type name '" + typeName + "'");
			JsonTokenizer tokenizer2 = JsonTokenizer.FromReplayedTokens(list, tokenizer);
			IMessage message2 = obj.Parser.CreateTemplate();
			if (obj.IsWellKnownType)
			{
				MergeWellKnownTypeAnyBody(message2, tokenizer2);
			}
			else
			{
				Merge(message2, tokenizer2);
			}
			ByteString value = message2.ToByteString();
			message.Descriptor.Fields[1].Accessor.SetValue(message, stringValue);
			message.Descriptor.Fields[2].Accessor.SetValue(message, value);
		}

		private void MergeWellKnownTypeAnyBody(IMessage body, JsonTokenizer tokenizer)
		{
			JsonToken jsonToken = tokenizer.Next();
			jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.Name || jsonToken.StringValue != "value")
			{
				throw new InvalidProtocolBufferException("Expected 'value' property for well-known type Any body");
			}
			Merge(body, tokenizer);
			jsonToken = tokenizer.Next();
			if (jsonToken.Type != JsonToken.TokenType.EndObject)
			{
				throw new InvalidProtocolBufferException("Expected end-object token after @type/value for well-known type");
			}
		}

		private static object ParseMapKey(FieldDescriptor field, string keyText)
		{
			switch (field.FieldType)
			{
			case FieldType.Bool:
				if (keyText == "true")
				{
					return true;
				}
				if (keyText == "false")
				{
					return false;
				}
				throw new InvalidProtocolBufferException("Invalid string for bool map key: " + keyText);
			case FieldType.String:
				return keyText;
			case FieldType.Int32:
			case FieldType.SFixed32:
			case FieldType.SInt32:
				return ParseNumericString(keyText, int.Parse);
			case FieldType.Fixed32:
			case FieldType.UInt32:
				return ParseNumericString(keyText, uint.Parse);
			case FieldType.Int64:
			case FieldType.SFixed64:
			case FieldType.SInt64:
				return ParseNumericString(keyText, long.Parse);
			case FieldType.UInt64:
			case FieldType.Fixed64:
				return ParseNumericString(keyText, ulong.Parse);
			default:
				throw new InvalidProtocolBufferException("Invalid field type for map: " + field.FieldType);
			}
		}

		private static object ParseSingleNumberValue(FieldDescriptor field, JsonToken token)
		{
			double numberValue = token.NumberValue;
			checked
			{
				try
				{
					switch (field.FieldType)
					{
					case FieldType.Int32:
					case FieldType.SFixed32:
					case FieldType.SInt32:
						CheckInteger(numberValue);
						return (int)numberValue;
					case FieldType.Fixed32:
					case FieldType.UInt32:
						CheckInteger(numberValue);
						return (uint)numberValue;
					case FieldType.Int64:
					case FieldType.SFixed64:
					case FieldType.SInt64:
						CheckInteger(numberValue);
						return (long)numberValue;
					case FieldType.UInt64:
					case FieldType.Fixed64:
						CheckInteger(numberValue);
						return (ulong)numberValue;
					case FieldType.Double:
						return numberValue;
					case FieldType.Float:
						if (double.IsNaN(numberValue))
						{
							return float.NaN;
						}
						if (numberValue > 3.4028234663852886E+38 || numberValue < -3.4028234663852886E+38)
						{
							if (double.IsPositiveInfinity(numberValue))
							{
								return float.PositiveInfinity;
							}
							if (double.IsNegativeInfinity(numberValue))
							{
								return float.NegativeInfinity;
							}
							throw new InvalidProtocolBufferException($"Value out of range: {numberValue}");
						}
						return (float)numberValue;
					case FieldType.Enum:
						CheckInteger(numberValue);
						return (int)numberValue;
					default:
						throw new InvalidProtocolBufferException($"Unsupported conversion from JSON number for field type {field.FieldType}");
					}
				}
				catch (OverflowException)
				{
					throw new InvalidProtocolBufferException($"Value out of range: {numberValue}");
				}
			}
		}

		private static void CheckInteger(double value)
		{
			if (double.IsInfinity(value) || double.IsNaN(value))
			{
				throw new InvalidProtocolBufferException($"Value not an integer: {value}");
			}
			if (value != Math.Floor(value))
			{
				throw new InvalidProtocolBufferException($"Value not an integer: {value}");
			}
		}

		private static object ParseSingleStringValue(FieldDescriptor field, string text)
		{
			switch (field.FieldType)
			{
			case FieldType.String:
				return text;
			case FieldType.Bytes:
				try
				{
					return ByteString.FromBase64(text);
				}
				catch (FormatException innerException)
				{
					throw InvalidProtocolBufferException.InvalidBase64(innerException);
				}
			case FieldType.Int32:
			case FieldType.SFixed32:
			case FieldType.SInt32:
				return ParseNumericString(text, int.Parse);
			case FieldType.Fixed32:
			case FieldType.UInt32:
				return ParseNumericString(text, uint.Parse);
			case FieldType.Int64:
			case FieldType.SFixed64:
			case FieldType.SInt64:
				return ParseNumericString(text, long.Parse);
			case FieldType.UInt64:
			case FieldType.Fixed64:
				return ParseNumericString(text, ulong.Parse);
			case FieldType.Double:
			{
				double num2 = ParseNumericString(text, double.Parse);
				ValidateInfinityAndNan(text, double.IsPositiveInfinity(num2), double.IsNegativeInfinity(num2), double.IsNaN(num2));
				return num2;
			}
			case FieldType.Float:
			{
				float num = ParseNumericString(text, float.Parse);
				ValidateInfinityAndNan(text, float.IsPositiveInfinity(num), float.IsNegativeInfinity(num), float.IsNaN(num));
				return num;
			}
			case FieldType.Enum:
				return (field.EnumType.FindValueByName(text) ?? throw new InvalidProtocolBufferException("Invalid enum value: " + text + " for enum type: " + field.EnumType.FullName)).Number;
			default:
				throw new InvalidProtocolBufferException($"Unsupported conversion from JSON string for field type {field.FieldType}");
			}
		}

		private static IMessage NewMessageForField(FieldDescriptor field)
		{
			return field.MessageType.Parser.CreateTemplate();
		}

		private static T ParseNumericString<T>(string text, Func<string, NumberStyles, IFormatProvider, T> parser)
		{
			if (text.StartsWith("+"))
			{
				throw new InvalidProtocolBufferException("Invalid numeric value: " + text);
			}
			if (text.StartsWith("0") && text.Length > 1)
			{
				if (text[1] >= '0' && text[1] <= '9')
				{
					throw new InvalidProtocolBufferException("Invalid numeric value: " + text);
				}
			}
			else if (text.StartsWith("-0") && text.Length > 2 && text[2] >= '0' && text[2] <= '9')
			{
				throw new InvalidProtocolBufferException("Invalid numeric value: " + text);
			}
			try
			{
				return parser(text, NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
			}
			catch (FormatException)
			{
				throw new InvalidProtocolBufferException("Invalid numeric value for type: " + text);
			}
			catch (OverflowException)
			{
				throw new InvalidProtocolBufferException("Value out of range: " + text);
			}
		}

		private static void ValidateInfinityAndNan(string text, bool isPositiveInfinity, bool isNegativeInfinity, bool isNaN)
		{
			if ((isPositiveInfinity && text != "Infinity") || (isNegativeInfinity && text != "-Infinity") || (isNaN && text != "NaN"))
			{
				throw new InvalidProtocolBufferException("Invalid numeric value: " + text);
			}
		}

		private static void MergeTimestamp(IMessage message, JsonToken token)
		{
			if (token.Type != JsonToken.TokenType.StringValue)
			{
				throw new InvalidProtocolBufferException("Expected string value for Timestamp");
			}
			Match match = TimestampRegex.Match(token.StringValue);
			if (!match.Success)
			{
				throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
			}
			string value = match.Groups["datetime"].Value;
			string value2 = match.Groups["subseconds"].Value;
			string value3 = match.Groups["offset"].Value;
			try
			{
				Timestamp timestamp = Timestamp.FromDateTime(DateTime.ParseExact(value, "yyyy-MM-dd'T'HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal));
				int num = 0;
				if (value2 != "")
				{
					num = int.Parse(value2.Substring(1), CultureInfo.InvariantCulture) * SubsecondScalingFactors[value2.Length];
				}
				int num2 = 0;
				if (value3 != "Z")
				{
					int num3 = ((value3[0] == '-') ? 1 : (-1));
					int num4 = int.Parse(value3.Substring(1, 2), CultureInfo.InvariantCulture);
					int num5 = int.Parse(value3.Substring(4, 2));
					int num6 = num4 * 60 + num5;
					if (num6 > 1080)
					{
						throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
					}
					if (num6 == 0 && num3 == 1)
					{
						throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
					}
					num2 = num3 * num6 * 60;
				}
				if (num2 < 0 && num > 0)
				{
					num2++;
					num -= 1000000000;
				}
				if (num2 != 0 || num != 0)
				{
					timestamp += new Duration
					{
						Nanos = num,
						Seconds = num2
					};
					if (timestamp.Seconds < -62135596800L || timestamp.Seconds > 253402300799L)
					{
						throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
					}
				}
				message.Descriptor.Fields[1].Accessor.SetValue(message, timestamp.Seconds);
				message.Descriptor.Fields[2].Accessor.SetValue(message, timestamp.Nanos);
			}
			catch (FormatException)
			{
				throw new InvalidProtocolBufferException("Invalid Timestamp value: " + token.StringValue);
			}
		}

		private static void MergeDuration(IMessage message, JsonToken token)
		{
			if (token.Type != JsonToken.TokenType.StringValue)
			{
				throw new InvalidProtocolBufferException("Expected string value for Duration");
			}
			Match match = DurationRegex.Match(token.StringValue);
			if (!match.Success)
			{
				throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
			}
			string value = match.Groups["sign"].Value;
			string value2 = match.Groups["int"].Value;
			if (value2[0] == '0' && value2.Length > 1)
			{
				throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
			}
			string value3 = match.Groups["subseconds"].Value;
			int num = ((!(value == "-")) ? 1 : (-1));
			try
			{
				long num2 = long.Parse(value2, CultureInfo.InvariantCulture) * num;
				int num3 = 0;
				if (value3 != "")
				{
					num3 = int.Parse(value3.Substring(1)) * SubsecondScalingFactors[value3.Length] * num;
				}
				if (!Duration.IsNormalized(num2, num3))
				{
					throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
				}
				message.Descriptor.Fields[1].Accessor.SetValue(message, num2);
				message.Descriptor.Fields[2].Accessor.SetValue(message, num3);
			}
			catch (FormatException)
			{
				throw new InvalidProtocolBufferException("Invalid Duration value: " + token.StringValue);
			}
		}

		private static void MergeFieldMask(IMessage message, JsonToken token)
		{
			if (token.Type != JsonToken.TokenType.StringValue)
			{
				throw new InvalidProtocolBufferException("Expected string value for FieldMask");
			}
			string[] array = token.StringValue.Split(FieldMaskPathSeparators, StringSplitOptions.RemoveEmptyEntries);
			IList list = (IList)message.Descriptor.Fields[1].Accessor.GetValue(message);
			string[] array2 = array;
			foreach (string text in array2)
			{
				list.Add(ToSnakeCase(text));
			}
		}

		private static string ToSnakeCase(string text)
		{
			StringBuilder stringBuilder = new StringBuilder(text.Length * 2);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (c >= 'A' && c <= 'Z')
				{
					if (flag && (flag2 || (i + 1 < text.Length && text[i + 1] >= 'a' && text[i + 1] <= 'z')))
					{
						stringBuilder.Append('_');
					}
					stringBuilder.Append((char)(c + 97 - 65));
					flag = true;
					flag2 = false;
				}
				else
				{
					stringBuilder.Append(c);
					if (c == '_')
					{
						throw new InvalidProtocolBufferException("Invalid field mask: " + text);
					}
					flag = true;
					flag2 = true;
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class JsonToken : IEquatable<JsonToken>
	{
		internal enum TokenType
		{
			Null,
			False,
			True,
			StringValue,
			Number,
			Name,
			StartObject,
			EndObject,
			StartArray,
			EndArray,
			EndDocument
		}

		private static readonly JsonToken _true = new JsonToken(TokenType.True);

		private static readonly JsonToken _false = new JsonToken(TokenType.False);

		private static readonly JsonToken _null = new JsonToken(TokenType.Null);

		private static readonly JsonToken startObject = new JsonToken(TokenType.StartObject);

		private static readonly JsonToken endObject = new JsonToken(TokenType.EndObject);

		private static readonly JsonToken startArray = new JsonToken(TokenType.StartArray);

		private static readonly JsonToken endArray = new JsonToken(TokenType.EndArray);

		private static readonly JsonToken endDocument = new JsonToken(TokenType.EndDocument);

		private readonly TokenType type;

		private readonly string stringValue;

		private readonly double numberValue;

		internal static JsonToken Null => _null;

		internal static JsonToken False => _false;

		internal static JsonToken True => _true;

		internal static JsonToken StartObject => startObject;

		internal static JsonToken EndObject => endObject;

		internal static JsonToken StartArray => startArray;

		internal static JsonToken EndArray => endArray;

		internal static JsonToken EndDocument => endDocument;

		internal TokenType Type => type;

		internal string StringValue => stringValue;

		internal double NumberValue => numberValue;

		internal static JsonToken Name(string name)
		{
			return new JsonToken(TokenType.Name, name);
		}

		internal static JsonToken Value(string value)
		{
			return new JsonToken(TokenType.StringValue, value);
		}

		internal static JsonToken Value(double value)
		{
			return new JsonToken(TokenType.Number, null, value);
		}

		private JsonToken(TokenType type, string stringValue = null, double numberValue = 0.0)
		{
			this.type = type;
			this.stringValue = stringValue;
			this.numberValue = numberValue;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as JsonToken);
		}

		public override int GetHashCode()
		{
			int num = (((int)(17 * 31 + type) * 31 + stringValue != null) ? stringValue.GetHashCode() : 0) * 31;
			double num2 = numberValue;
			return num + num2.GetHashCode();
		}

		public override string ToString()
		{
			switch (type)
			{
			case TokenType.Null:
				return "null";
			case TokenType.True:
				return "true";
			case TokenType.False:
				return "false";
			case TokenType.Name:
				return "name (" + stringValue + ")";
			case TokenType.StringValue:
				return "value (" + stringValue + ")";
			case TokenType.Number:
			{
				double num = numberValue;
				return "number (" + num + ")";
			}
			case TokenType.StartObject:
				return "start-object";
			case TokenType.EndObject:
				return "end-object";
			case TokenType.StartArray:
				return "start-array";
			case TokenType.EndArray:
				return "end-array";
			case TokenType.EndDocument:
				return "end-document";
			default:
				throw new InvalidOperationException("Token is of unknown type " + type);
			}
		}

		public bool Equals(JsonToken other)
		{
			if (other == null)
			{
				return false;
			}
			if (other.type == type && other.stringValue == stringValue)
			{
				double num = other.numberValue;
				return num.Equals(numberValue);
			}
			return false;
		}
	}
	internal abstract class JsonTokenizer
	{
		private class JsonReplayTokenizer : JsonTokenizer
		{
			private readonly IList<JsonToken> tokens;

			private readonly JsonTokenizer nextTokenizer;

			private int nextTokenIndex;

			internal JsonReplayTokenizer(IList<JsonToken> tokens, JsonTokenizer nextTokenizer)
			{
				this.tokens = tokens;
				this.nextTokenizer = nextTokenizer;
			}

			protected override JsonToken NextImpl()
			{
				if (nextTokenIndex >= tokens.Count)
				{
					return nextTokenizer.Next();
				}
				return tokens[nextTokenIndex++];
			}
		}

		private sealed class JsonTextTokenizer : JsonTokenizer
		{
			private enum ContainerType
			{
				Document,
				Object,
				Array
			}

			[Flags]
			private enum State
			{
				StartOfDocument = 1,
				ExpectedEndOfDocument = 2,
				ReaderExhausted = 4,
				ObjectStart = 8,
				ObjectBeforeColon = 0x10,
				ObjectAfterColon = 0x20,
				ObjectAfterProperty = 0x40,
				ObjectAfterComma = 0x80,
				ArrayStart = 0x100,
				ArrayAfterValue = 0x200,
				ArrayAfterComma = 0x400
			}

			private class PushBackReader
			{
				private readonly TextReader reader;

				private char? nextChar;

				internal PushBackReader(TextReader reader)
				{
					this.reader = reader;
				}

				internal char? Read()
				{
					if (nextChar.HasValue)
					{
						char? result = nextChar;
						nextChar = null;
						return result;
					}
					int num = reader.Read();
					if (num != -1)
					{
						return (char)num;
					}
					return null;
				}

				internal char ReadOrFail(string messageOnFailure)
				{
					char? c = Read();
					if (!c.HasValue)
					{
						throw CreateException(messageOnFailure);
					}
					return c.Value;
				}

				internal void PushBack(char c)
				{
					if (nextChar.HasValue)
					{
						throw new InvalidOperationException("Cannot push back when already buffering a character");
					}
					nextChar = c;
				}

				internal InvalidJsonException CreateException(string message)
				{
					return new InvalidJsonException(message);
				}
			}

			private static readonly State ValueStates = State.StartOfDocument | State.ObjectAfterColon | State.ArrayStart | State.ArrayAfterComma;

			private readonly Stack<ContainerType> containerStack = new Stack<ContainerType>();

			private readonly PushBackReader reader;

			private State state;

			internal JsonTextTokenizer(TextReader reader)
			{
				this.reader = new PushBackReader(reader);
				state = State.StartOfDocument;
				containerStack.Push(ContainerType.Document);
			}

			protected override JsonToken NextImpl()
			{
				if (state == State.ReaderExhausted)
				{
					throw new InvalidOperationException("Next() called after end of document");
				}
				while (true)
				{
					char? c = reader.Read();
					if (!c.HasValue)
					{
						break;
					}
					switch (c.Value)
					{
					case '\t':
					case '\n':
					case '\r':
					case ' ':
						break;
					case ':':
						ValidateState(State.ObjectBeforeColon, "Invalid state to read a colon: ");
						state = State.ObjectAfterColon;
						break;
					case ',':
						ValidateState(State.ObjectAfterProperty | State.ArrayAfterValue, "Invalid state to read a comma: ");
						state = ((state == State.ObjectAfterProperty) ? State.ObjectAfterComma : State.ArrayAfterComma);
						break;
					case '"':
					{
						string text = ReadString();
						if ((state & (State.ObjectStart | State.ObjectAfterComma)) != 0)
						{
							state = State.ObjectBeforeColon;
							return JsonToken.Name(text);
						}
						ValidateAndModifyStateForValue("Invalid state to read a double quote: ");
						return JsonToken.Value(text);
					}
					case '{':
						ValidateState(ValueStates, "Invalid state to read an open brace: ");
						state = State.ObjectStart;
						containerStack.Push(ContainerType.Object);
						return JsonToken.StartObject;
					case '}':
						ValidateState(State.ObjectStart | State.ObjectAfterProperty, "Invalid state to read a close brace: ");
						PopContainer();
						return JsonToken.EndObject;
					case '[':
						ValidateState(ValueStates, "Invalid state to read an open square bracket: ");
						state = State.ArrayStart;
						containerStack.Push(ContainerType.Array);
						return JsonToken.StartArray;
					case ']':
						ValidateState(State.ArrayStart | State.ArrayAfterValue, "Invalid state to read a close square bracket: ");
						PopContainer();
						return JsonToken.EndArray;
					case 'n':
						ConsumeLiteral("null");
						ValidateAndModifyStateForValue("Invalid state to read a null literal: ");
						return JsonToken.Null;
					case 't':
						ConsumeLiteral("true");
						ValidateAndModifyStateForValue("Invalid state to read a true literal: ");
						return JsonToken.True;
					case 'f':
						ConsumeLiteral("false");
						ValidateAndModifyStateForValue("Invalid state to read a false literal: ");
						return JsonToken.False;
					case '-':
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
					{
						double value = ReadNumber(c.Value);
						ValidateAndModifyStateForValue("Invalid state to read a number token: ");
						return JsonToken.Value(value);
					}
					default:
						throw new InvalidJsonException("Invalid first character of token: " + c.Value);
					}
				}
				ValidateState(State.ExpectedEndOfDocument, "Unexpected end of document in state: ");
				state = State.ReaderExhausted;
				return JsonToken.EndDocument;
			}

			private void ValidateState(State validStates, string errorPrefix)
			{
				if ((validStates & state) == 0)
				{
					throw reader.CreateException(errorPrefix + state);
				}
			}

			private string ReadString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				bool flag = false;
				while (true)
				{
					char c = reader.ReadOrFail("Unexpected end of text while reading string");
					if (c < ' ')
					{
						throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in string literal: U+{0:x4}", (int)c));
					}
					switch (c)
					{
					case '"':
						if (flag)
						{
							throw reader.CreateException("Invalid use of surrogate pair code units");
						}
						return stringBuilder.ToString();
					case '\\':
						c = ReadEscapedCharacter();
						break;
					}
					if (flag != char.IsLowSurrogate(c))
					{
						break;
					}
					flag = char.IsHighSurrogate(c);
					stringBuilder.Append(c);
				}
				throw reader.CreateException("Invalid use of surrogate pair code units");
			}

			private char ReadEscapedCharacter()
			{
				char c = reader.ReadOrFail("Unexpected end of text while reading character escape sequence");
				return c switch
				{
					'n' => '\n', 
					'\\' => '\\', 
					'b' => '\b', 
					'f' => '\f', 
					'r' => '\r', 
					't' => '\t', 
					'"' => '"', 
					'/' => '/', 
					'u' => ReadUnicodeEscape(), 
					_ => throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", (int)c)), 
				};
			}

			private char ReadUnicodeEscape()
			{
				int num = 0;
				for (int i = 0; i < 4; i++)
				{
					char c = reader.ReadOrFail("Unexpected end of text while reading Unicode escape sequence");
					int num2;
					if (c >= '0' && c <= '9')
					{
						num2 = c - 48;
					}
					else if (c >= 'a' && c <= 'f')
					{
						num2 = c - 97 + 10;
					}
					else
					{
						if (c < 'A' || c > 'F')
						{
							throw reader.CreateException(string.Format(CultureInfo.InvariantCulture, "Invalid character in character escape sequence: U+{0:x4}", (int)c));
						}
						num2 = c - 65 + 10;
					}
					num = (num << 4) + num2;
				}
				return (char)num;
			}

			private void ConsumeLiteral(string text)
			{
				for (int i = 1; i < text.Length; i++)
				{
					char? c = reader.Read();
					if (!c.HasValue)
					{
						throw reader.CreateException("Unexpected end of text while reading literal token " + text);
					}
					if (c.Value != text[i])
					{
						throw reader.CreateException("Unexpected character while reading literal token " + text);
					}
				}
			}

			private double ReadNumber(char initialCharacter)
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (initialCharacter == '-')
				{
					stringBuilder.Append("-");
				}
				else
				{
					reader.PushBack(initialCharacter);
				}
				char? c = ReadInt(stringBuilder);
				if (c == '.')
				{
					c = ReadFrac(stringBuilder);
				}
				if (c == 'e' || c == 'E')
				{
					c = ReadExp(stringBuilder);
				}
				if (c.HasValue)
				{
					reader.PushBack(c.Value);
				}
				try
				{
					double num = double.Parse(stringBuilder.ToString(), NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent, CultureInfo.InvariantCulture);
					if (double.IsInfinity(num))
					{
						throw reader.CreateException("Numeric value out of range: " + stringBuilder);
					}
					return num;
				}
				catch (OverflowException)
				{
					throw reader.CreateException("Numeric value out of range: " + stringBuilder);
				}
			}

			private char? ReadInt(StringBuilder builder)
			{
				char c = reader.ReadOrFail("Invalid numeric literal");
				if (c < '0' || c > '9')
				{
					throw reader.CreateException("Invalid numeric literal");
				}
				builder.Append(c);
				int count;
				char? result = ConsumeDigits(builder, out count);
				if (c == '0' && count != 0)
				{
					throw reader.CreateException("Invalid numeric literal: leading 0 for non-zero value.");
				}
				return result;
			}

			private char? ReadFrac(StringBuilder builder)
			{
				builder.Append('.');
				int count;
				char? result = ConsumeDigits(builder, out count);
				if (count == 0)
				{
					throw reader.CreateException("Invalid numeric literal: fraction with no trailing digits");
				}
				return result;
			}

			private char? ReadExp(StringBuilder builder)
			{
				builder.Append('E');
				char? c = reader.Read();
				if (!c.HasValue)
				{
					throw reader.CreateException("Invalid numeric literal: exponent with no trailing digits");
				}
				if (c == '-' || c == '+')
				{
					builder.Append(c.Value);
				}
				else
				{
					reader.PushBack(c.Value);
				}
				c = ConsumeDigits(builder, out var count);
				if (count == 0)
				{
					throw reader.CreateException("Invalid numeric literal: exponent without value");
				}
				return c;
			}

			private char? ConsumeDigits(StringBuilder builder, out int count)
			{
				count = 0;
				char? result;
				while (true)
				{
					result = reader.Read();
					if (!result.HasValue || result.Value < '0' || result.Value > '9')
					{
						break;
					}
					count++;
					builder.Append(result.Value);
				}
				return result;
			}

			private void ValidateAndModifyStateForValue(string errorPrefix)
			{
				ValidateState(ValueStates, errorPrefix);
				switch (state)
				{
				case State.StartOfDocument:
					state = State.ExpectedEndOfDocument;
					break;
				case State.ObjectAfterColon:
					state = State.ObjectAfterProperty;
					break;
				case State.ArrayStart:
				case State.ArrayAfterComma:
					state = State.ArrayAfterValue;
					break;
				default:
					throw new InvalidOperationException("ValidateAndModifyStateForValue does not handle all value states (and should)");
				}
			}

			private void PopContainer()
			{
				containerStack.Pop();
				ContainerType containerType = containerStack.Peek();
				switch (containerType)
				{
				case ContainerType.Object:
					state = State.ObjectAfterProperty;
					break;
				case ContainerType.Array:
					state = State.ArrayAfterValue;
					break;
				case ContainerType.Document:
					state = State.ExpectedEndOfDocument;
					break;
				default:
					throw new InvalidOperationException("Unexpected container type: " + containerType);
				}
			}
		}

		private JsonToken bufferedToken;

		internal int ObjectDepth { get; private set; }

		internal static JsonTokenizer FromTextReader(TextReader reader)
		{
			return new JsonTextTokenizer(reader);
		}

		internal static JsonTokenizer FromReplayedTokens(IList<JsonToken> tokens, JsonTokenizer continuation)
		{
			return new JsonReplayTokenizer(tokens, continuation);
		}

		internal void PushBack(JsonToken token)
		{
			if (bufferedToken != null)
			{
				throw new InvalidOperationException("Can't push back twice");
			}
			bufferedToken = token;
			if (token.Type == JsonToken.TokenType.StartObject)
			{
				ObjectDepth--;
			}
			else if (token.Type == JsonToken.TokenType.EndObject)
			{
				ObjectDepth++;
			}
		}

		internal JsonToken Next()
		{
			JsonToken jsonToken;
			if (bufferedToken != null)
			{
				jsonToken = bufferedToken;
				bufferedToken = null;
			}
			else
			{
				jsonToken = NextImpl();
			}
			if (jsonToken.Type == JsonToken.TokenType.StartObject)
			{
				ObjectDepth++;
			}
			else if (jsonToken.Type == JsonToken.TokenType.EndObject)
			{
				ObjectDepth--;
			}
			return jsonToken;
		}

		protected abstract JsonToken NextImpl();

		internal void SkipValue()
		{
			int num = 0;
			do
			{
				switch (Next().Type)
				{
				case JsonToken.TokenType.EndObject:
				case JsonToken.TokenType.EndArray:
					num--;
					break;
				case JsonToken.TokenType.StartObject:
				case JsonToken.TokenType.StartArray:
					num++;
					break;
				}
			}
			while (num != 0);
		}
	}
	internal sealed class LimitedInputStream : Stream
	{
		private readonly Stream proxied;

		private int bytesLeft;

		public override bool CanRead => true;

		public override bool CanSeek => false;

		public override bool CanWrite => false;

		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override long Position
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		internal LimitedInputStream(Stream proxied, int size)
		{
			this.proxied = proxied;
			bytesLeft = size;
		}

		public override void Flush()
		{
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (bytesLeft > 0)
			{
				int num = proxied.Read(buffer, offset, Math.Min(bytesLeft, count));
				bytesLeft -= num;
				return num;
			}
			return 0;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException();
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException();
		}
	}
	public static class MessageExtensions
	{
		public static void MergeFrom(this IMessage message, byte[] data)
		{
			message.MergeFrom(data, discardUnknownFields: false, null);
		}

		public static void MergeFrom(this IMessage message, byte[] data, int offset, int length)
		{
			message.MergeFrom(data, offset, length, discardUnknownFields: false, null);
		}

		public static void MergeFrom(this IMessage message, ByteString data)
		{
			message.MergeFrom(data, discardUnknownFields: false, null);
		}

		public static void MergeFrom(this IMessage message, Stream input)
		{
			message.MergeFrom(input, discardUnknownFields: false, null);
		}

		[SecuritySafeCritical]
		public static void MergeFrom(this IMessage message, ReadOnlySpan<byte> span)
		{
			message.MergeFrom(span, discardUnknownFields: false, null);
		}

		public static void MergeDelimitedFrom(this IMessage message, Stream input)
		{
			message.MergeDelimitedFrom(input, discardUnknownFields: false, null);
		}

		public static byte[] ToByteArray(this IMessage message)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			byte[] array = new byte[message.CalculateSize()];
			CodedOutputStream codedOutputStream = new CodedOutputStream(array);
			message.WriteTo(codedOutputStream);
			codedOutputStream.CheckNoSpaceLeft();
			return array;
		}

		public static void WriteTo(this IMessage message, Stream output)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(output, "output");
			CodedOutputStream codedOutputStream = new CodedOutputStream(output);
			message.WriteTo(codedOutputStream);
			codedOutputStream.Flush();
		}

		public static void WriteDelimitedTo(this IMessage message, Stream output)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(output, "output");
			CodedOutputStream codedOutputStream = new CodedOutputStream(output);
			codedOutputStream.WriteLength(message.CalculateSize());
			message.WriteTo(codedOutputStream);
			codedOutputStream.Flush();
		}

		public static ByteString ToByteString(this IMessage message)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			return ByteString.AttachBytes(message.ToByteArray());
		}

		[SecuritySafeCritical]
		public static void WriteTo(this IMessage message, IBufferWriter<byte> output)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(output, "output");
			WriteContext.Initialize(output, out var ctx);
			WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
			ctx.Flush();
		}

		[SecuritySafeCritical]
		public static void WriteTo(this IMessage message, Span<byte> output)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			WriteContext.Initialize(ref output, out var ctx);
			WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
			ctx.CheckNoSpaceLeft();
		}

		public static bool IsInitialized(this IMessage message)
		{
			if (message.Descriptor.File.Syntax == Google.Protobuf.Reflection.Syntax.Proto3)
			{
				return true;
			}
			if (!message.Descriptor.IsExtensionsInitialized(message))
			{
				return false;
			}
			return message.Descriptor.Fields.InDeclarationOrder().All(delegate(FieldDescriptor f)
			{
				if (f.IsMap)
				{
					if (f.MessageType.Fields[2].FieldType == FieldType.Message)
					{
						return ((IDictionary)f.Accessor.GetValue(message)).Values.Cast<IMessage>().All(IsInitialized);
					}
					return true;
				}
				if ((f.IsRepeated && f.FieldType == FieldType.Message) || f.FieldType == FieldType.Group)
				{
					return ((IEnumerable)f.Accessor.GetValue(message)).Cast<IMessage>().All(IsInitialized);
				}
				if (f.FieldType == FieldType.Message || f.FieldType == FieldType.Group)
				{
					if (f.Accessor.HasValue(message))
					{
						return ((IMessage)f.Accessor.GetValue(message)).IsInitialized();
					}
					return !f.IsRequired;
				}
				return !f.IsRequired || f.Accessor.HasValue(message);
			});
		}

		internal static void MergeFrom(this IMessage message, byte[] data, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(data, "data");
			CodedInputStream codedInputStream = new CodedInputStream(data);
			codedInputStream.DiscardUnknownFields = discardUnknownFields;
			codedInputStream.ExtensionRegistry = registry;
			message.MergeFrom(codedInputStream);
			codedInputStream.CheckReadEndOfStreamTag();
		}

		internal static void MergeFrom(this IMessage message, byte[] data, int offset, int length, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(data, "data");
			CodedInputStream codedInputStream = new CodedInputStream(data, offset, length);
			codedInputStream.DiscardUnknownFields = discardUnknownFields;
			codedInputStream.ExtensionRegistry = registry;
			message.MergeFrom(codedInputStream);
			codedInputStream.CheckReadEndOfStreamTag();
		}

		internal static void MergeFrom(this IMessage message, ByteString data, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(data, "data");
			CodedInputStream codedInputStream = data.CreateCodedInput();
			codedInputStream.DiscardUnknownFields = discardUnknownFields;
			codedInputStream.ExtensionRegistry = registry;
			message.MergeFrom(codedInputStream);
			codedInputStream.CheckReadEndOfStreamTag();
		}

		internal static void MergeFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(input, "input");
			CodedInputStream codedInputStream = new CodedInputStream(input);
			codedInputStream.DiscardUnknownFields = discardUnknownFields;
			codedInputStream.ExtensionRegistry = registry;
			message.MergeFrom(codedInputStream);
			codedInputStream.CheckReadEndOfStreamTag();
		}

		[SecuritySafeCritical]
		internal static void MergeFrom(this IMessage message, ReadOnlySequence<byte> data, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ParseContext.Initialize(data, out var ctx);
			ctx.DiscardUnknownFields = discardUnknownFields;
			ctx.ExtensionRegistry = registry;
			ParsingPrimitivesMessages.ReadRawMessage(ref ctx, message);
			ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref ctx.state);
		}

		[SecuritySafeCritical]
		internal static void MergeFrom(this IMessage message, ReadOnlySpan<byte> data, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ParseContext.Initialize(data, out var ctx);
			ctx.DiscardUnknownFields = discardUnknownFields;
			ctx.ExtensionRegistry = registry;
			ParsingPrimitivesMessages.ReadRawMessage(ref ctx, message);
			ParsingPrimitivesMessages.CheckReadEndOfStreamTag(ref ctx.state);
		}

		internal static void MergeDelimitedFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(input, "input");
			int size = (int)CodedInputStream.ReadRawVarint32(input);
			Stream input2 = new LimitedInputStream(input, size);
			message.MergeFrom(input2, discardUnknownFields, registry);
		}
	}
	public class MessageParser
	{
		private Func<IMessage> factory;

		internal bool DiscardUnknownFields { get; }

		internal ExtensionRegistry Extensions { get; }

		internal MessageParser(Func<IMessage> factory, bool discardUnknownFields, ExtensionRegistry extensions)
		{
			this.factory = factory;
			DiscardUnknownFields = discardUnknownFields;
			Extensions = extensions;
		}

		internal IMessage CreateTemplate()
		{
			return factory();
		}

		public IMessage ParseFrom(byte[] data)
		{
			IMessage message = factory();
			message.MergeFrom(data, DiscardUnknownFields, Extensions);
			return message;
		}

		public IMessage ParseFrom(byte[] data, int offset, int length)
		{
			IMessage message = factory();
			message.MergeFrom(data, offset, length, DiscardUnknownFields, Extensions);
			return message;
		}

		public IMessage ParseFrom(ByteString data)
		{
			IMessage message = factory();
			message.MergeFrom(data, DiscardUnknownFields, Extensions);
			return message;
		}

		public IMessage ParseFrom(Stream input)
		{
			IMessage message = factory();
			message.MergeFrom(input, DiscardUnknownFields, Extensions);
			return message;
		}

		[SecuritySafeCritical]
		public IMessage ParseFrom(ReadOnlySequence<byte> data)
		{
			IMessage message = factory();
			message.MergeFrom(data, DiscardUnknownFields, Extensions);
			return message;
		}

		[SecuritySafeCritical]
		public IMessage ParseFrom(ReadOnlySpan<byte> data)
		{
			IMessage message = factory();
			message.MergeFrom(data, DiscardUnknownFields, Extensions);
			return message;
		}

		public IMessage ParseDelimitedFrom(Stream input)
		{
			IMessage message = factory();
			message.MergeDelimitedFrom(input, DiscardUnknownFields, Extensions);
			return message;
		}

		public IMessage ParseFrom(CodedInputStream input)
		{
			IMessage message = factory();
			MergeFrom(message, input);
			return message;
		}

		public IMessage ParseJson(string json)
		{
			IMessage message = factory();
			JsonParser.Default.Merge(message, json);
			return message;
		}

		internal void MergeFrom(IMessage message, CodedInputStream codedInput)
		{
			bool discardUnknownFields = codedInput.DiscardUnknownFields;
			ExtensionRegistry extensionRegistry = codedInput.ExtensionRegistry;
			try
			{
				codedInput.DiscardUnknownFields = DiscardUnknownFields;
				codedInput.ExtensionRegistry = Extensions;
				message.MergeFrom(codedInput);
			}
			finally
			{
				codedInput.DiscardUnknownFields = discardUnknownFields;
				codedInput.ExtensionRegistry = extensionRegistry;
			}
		}

		public MessageParser WithDiscardUnknownFields(bool discardUnknownFields)
		{
			return new MessageParser(factory, discardUnknownFields, Extensions);
		}

		public MessageParser WithExtensionRegistry(ExtensionRegistry registry)
		{
			return new MessageParser(factory, DiscardUnknownFields, registry);
		}
	}
	public sealed class MessageParser<T> : MessageParser where T : IMessage<T>
	{
		private readonly Func<T> factory;

		public MessageParser(Func<T> factory)
			: this(factory, discardUnknownFields: false, (ExtensionRegistry)null)
		{
		}

		internal MessageParser(Func<T> factory, bool discardUnknownFields, ExtensionRegistry extensions)
			: base(() => factory(), discardUnknownFields, extensions)
		{
			this.factory = factory;
		}

		internal new T CreateTemplate()
		{
			return factory();
		}

		public new T ParseFrom(byte[] data)
		{
			T val = factory();
			val.MergeFrom(data, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		public new T ParseFrom(byte[] data, int offset, int length)
		{
			T val = factory();
			val.MergeFrom(data, offset, length, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		public new T ParseFrom(ByteString data)
		{
			T val = factory();
			val.MergeFrom(data, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		public new T ParseFrom(Stream input)
		{
			T val = factory();
			val.MergeFrom(input, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		[SecuritySafeCritical]
		public new T ParseFrom(ReadOnlySequence<byte> data)
		{
			T val = factory();
			val.MergeFrom(data, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		[SecuritySafeCritical]
		public new T ParseFrom(ReadOnlySpan<byte> data)
		{
			T val = factory();
			val.MergeFrom(data, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		public new T ParseDelimitedFrom(Stream input)
		{
			T val = factory();
			val.MergeDelimitedFrom(input, base.DiscardUnknownFields, base.Extensions);
			return val;
		}

		public new T ParseFrom(CodedInputStream input)
		{
			T val = factory();
			MergeFrom(val, input);
			return val;
		}

		public new T ParseJson(string json)
		{
			T val = factory();
			JsonParser.Default.Merge(val, json);
			return val;
		}

		public new MessageParser<T> WithDiscardUnknownFields(bool discardUnknownFields)
		{
			return new MessageParser<T>(factory, discardUnknownFields, base.Extensions);
		}

		public new MessageParser<T> WithExtensionRegistry(ExtensionRegistry registry)
		{
			return new MessageParser<T>(factory, base.DiscardUnknownFields, registry);
		}
	}
	internal struct ObjectIntPair<T> : IEquatable<ObjectIntPair<T>> where T : class
	{
		private readonly int number;

		private readonly T obj;

		internal ObjectIntPair(T obj, int number)
		{
			this.number = number;
			this.obj = obj;
		}

		public bool Equals(ObjectIntPair<T> other)
		{
			if (obj == other.obj)
			{
				return number == other.number;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is ObjectIntPair<T>)
			{
				return Equals((ObjectIntPair<T>)obj);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return obj.GetHashCode() * 65535 + number;
		}
	}
	[SecuritySafeCritical]
	public ref struct ParseContext
	{
		internal const int DefaultRecursionLimit = 100;

		internal const int DefaultSizeLimit = int.MaxValue;

		internal ReadOnlySpan<byte> buffer;

		internal ParserInternalState state;

		internal uint LastTag => state.lastTag;

		internal bool DiscardUnknownFields
		{
			get
			{
				return state.DiscardUnknownFields;
			}
			set
			{
				state.DiscardUnknownFields = value;
			}
		}

		internal ExtensionRegistry ExtensionRegistry
		{
			get
			{
				return state.ExtensionRegistry;
			}
			set
			{
				state.ExtensionRegistry = value;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ReadOnlySpan<byte> buffer, out ParseContext ctx)
		{
			ParserInternalState parserInternalState = new ParserInternalState
			{
				sizeLimit = int.MaxValue,
				recursionLimit = 100,
				currentLimit = int.MaxValue,
				bufferSize = buffer.Length
			};
			Initialize(buffer, ref parserInternalState, out ctx);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ReadOnlySpan<byte> buffer, ref ParserInternalState state, out ParseContext ctx)
		{
			ctx.buffer = buffer;
			ctx.state = state;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(CodedInputStream input, out ParseContext ctx)
		{
			ctx.buffer = new ReadOnlySpan<byte>(input.InternalBuffer);
			ctx.state = input.InternalState;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ReadOnlySequence<byte> input, out ParseContext ctx)
		{
			Initialize(input, 100, out ctx);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ReadOnlySequence<byte> input, int recursionLimit, out ParseContext ctx)
		{
			ctx.buffer = default(ReadOnlySpan<byte>);
			ctx.state = default(ParserInternalState);
			ctx.state.lastTag = 0u;
			ctx.state.recursionDepth = 0;
			ctx.state.sizeLimit = int.MaxValue;
			ctx.state.recursionLimit = recursionLimit;
			ctx.state.currentLimit = int.MaxValue;
			SegmentedBufferHelper.Initialize(input, out ctx.state.segmentedBufferHelper, out ctx.buffer);
			ctx.state.bufferPos = 0;
			ctx.state.bufferSize = ctx.buffer.Length;
			ctx.state.DiscardUnknownFields = false;
			ctx.state.ExtensionRegistry = null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public uint ReadTag()
		{
			return ParsingPrimitives.ParseTag(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public double ReadDouble()
		{
			return ParsingPrimitives.ParseDouble(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public float ReadFloat()
		{
			return ParsingPrimitives.ParseFloat(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ulong ReadUInt64()
		{
			return ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long ReadInt64()
		{
			return (long)ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadInt32()
		{
			return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ulong ReadFixed64()
		{
			return ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public uint ReadFixed32()
		{
			return ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool ReadBool()
		{
			return ParsingPrimitives.ParseRawVarint64(ref buffer, ref state) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string ReadString()
		{
			return ParsingPrimitives.ReadString(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ReadMessage(IMessage message)
		{
			ParsingPrimitivesMessages.ReadMessage(ref this, message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ReadGroup(IMessage message)
		{
			ParsingPrimitivesMessages.ReadGroup(ref this, message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ByteString ReadBytes()
		{
			return ParsingPrimitives.ReadBytes(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public uint ReadUInt32()
		{
			return ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadEnum()
		{
			return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadSFixed32()
		{
			return (int)ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long ReadSFixed64()
		{
			return (long)ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadSInt32()
		{
			return ParsingPrimitives.DecodeZigZag32(ParsingPrimitives.ParseRawVarint32(ref buffer, ref state));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long ReadSInt64()
		{
			return ParsingPrimitives.DecodeZigZag64(ParsingPrimitives.ParseRawVarint64(ref buffer, ref state));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadLength()
		{
			return (int)ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
		}

		internal void CopyStateTo(CodedInputStream input)
		{
			input.InternalState = state;
		}

		internal void LoadStateFrom(CodedInputStream input)
		{
			state = input.InternalState;
		}
	}
	internal struct ParserInternalState
	{
		internal int bufferPos;

		internal int bufferSize;

		internal int bufferSizeAfterLimit;

		internal int currentLimit;

		internal int totalBytesRetired;

		internal int recursionDepth;

		internal SegmentedBufferHelper segmentedBufferHelper;

		internal uint lastTag;

		internal uint nextTag;

		internal bool hasNextTag;

		internal int sizeLimit;

		internal int recursionLimit;

		internal CodedInputStream CodedInputStream => segmentedBufferHelper.CodedInputStream;

		internal bool DiscardUnknownFields { get; set; }

		internal ExtensionRegistry ExtensionRegistry { get; set; }
	}
	[SecuritySafeCritical]
	internal static class ParsingPrimitives
	{
		private const int StackallocThreshold = 256;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ParseLength(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			return (int)ParseRawVarint32(ref buffer, ref state);
		}

		public static uint ParseTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.hasNextTag)
			{
				state.lastTag = state.nextTag;
				state.hasNextTag = false;
				return state.lastTag;
			}
			if (state.bufferPos + 2 <= state.bufferSize)
			{
				int num = buffer[state.bufferPos++];
				if (num < 128)
				{
					state.lastTag = (uint)num;
				}
				else
				{
					int num2 = num & 0x7F;
					if ((num = buffer[state.bufferPos++]) < 128)
					{
						num2 |= num << 7;
						state.lastTag = (uint)num2;
					}
					else
					{
						state.bufferPos -= 2;
						state.lastTag = ParseRawVarint32(ref buffer, ref state);
					}
				}
			}
			else
			{
				if (SegmentedBufferHelper.IsAtEnd(ref buffer, ref state))
				{
					state.lastTag = 0u;
					return 0u;
				}
				state.lastTag = ParseRawVarint32(ref buffer, ref state);
			}
			if (WireFormat.GetTagFieldNumber(state.lastTag) == 0)
			{
				throw InvalidProtocolBufferException.InvalidTag();
			}
			return state.lastTag;
		}

		public static bool MaybeConsumeTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint tag)
		{
			if (PeekTag(ref buffer, ref state) == tag)
			{
				state.hasNextTag = false;
				return true;
			}
			return false;
		}

		public static uint PeekTag(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.hasNextTag)
			{
				return state.nextTag;
			}
			uint lastTag = state.lastTag;
			state.nextTag = ParseTag(ref buffer, ref state);
			state.hasNextTag = true;
			state.lastTag = lastTag;
			return state.nextTag;
		}

		public static ulong ParseRawVarint64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 10 > state.bufferSize)
			{
				return ParseRawVarint64SlowPath(ref buffer, ref state);
			}
			ulong num = buffer[state.bufferPos++];
			if (num < 128)
			{
				return num;
			}
			num &= 0x7F;
			int num2 = 7;
			do
			{
				byte b = buffer[state.bufferPos++];
				num |= (ulong)((long)(b & 0x7F) << num2);
				if (b < 128)
				{
					return num;
				}
				num2 += 7;
			}
			while (num2 < 64);
			throw InvalidProtocolBufferException.MalformedVarint();
		}

		private static ulong ParseRawVarint64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = 0;
			ulong num2 = 0uL;
			do
			{
				byte b = ReadRawByte(ref buffer, ref state);
				num2 |= (ulong)((long)(b & 0x7F) << num);
				if (b < 128)
				{
					return num2;
				}
				num += 7;
			}
			while (num < 64);
			throw InvalidProtocolBufferException.MalformedVarint();
		}

		public static uint ParseRawVarint32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 5 > state.bufferSize)
			{
				return ParseRawVarint32SlowPath(ref buffer, ref state);
			}
			int num = buffer[state.bufferPos++];
			if (num < 128)
			{
				return (uint)num;
			}
			int num2 = num & 0x7F;
			if ((num = buffer[state.bufferPos++]) < 128)
			{
				num2 |= num << 7;
			}
			else
			{
				num2 |= (num & 0x7F) << 7;
				if ((num = buffer[state.bufferPos++]) < 128)
				{
					num2 |= num << 14;
				}
				else
				{
					num2 |= (num & 0x7F) << 14;
					if ((num = buffer[state.bufferPos++]) < 128)
					{
						num2 |= num << 21;
					}
					else
					{
						num2 |= (num & 0x7F) << 21;
						num2 |= (num = buffer[state.bufferPos++]) << 28;
						if (num >= 128)
						{
							for (int i = 0; i < 5; i++)
							{
								if (ReadRawByte(ref buffer, ref state) < 128)
								{
									return (uint)num2;
								}
							}
							throw InvalidProtocolBufferException.MalformedVarint();
						}
					}
				}
			}
			return (uint)num2;
		}

		private static uint ParseRawVarint32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = ReadRawByte(ref buffer, ref state);
			if (num < 128)
			{
				return (uint)num;
			}
			int num2 = num & 0x7F;
			if ((num = ReadRawByte(ref buffer, ref state)) < 128)
			{
				num2 |= num << 7;
			}
			else
			{
				num2 |= (num & 0x7F) << 7;
				if ((num = ReadRawByte(ref buffer, ref state)) < 128)
				{
					num2 |= num << 14;
				}
				else
				{
					num2 |= (num & 0x7F) << 14;
					if ((num = ReadRawByte(ref buffer, ref state)) < 128)
					{
						num2 |= num << 21;
					}
					else
					{
						num2 |= (num & 0x7F) << 21;
						num2 |= (num = ReadRawByte(ref buffer, ref state)) << 28;
						if (num >= 128)
						{
							for (int i = 0; i < 5; i++)
							{
								if (ReadRawByte(ref buffer, ref state) < 128)
								{
									return (uint)num2;
								}
							}
							throw InvalidProtocolBufferException.MalformedVarint();
						}
					}
				}
			}
			return (uint)num2;
		}

		public static uint ParseRawLittleEndian32(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 8 > state.bufferSize)
			{
				return ParseRawLittleEndian32SlowPath(ref buffer, ref state);
			}
			int result = (int)BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, 8));
			state.bufferPos += 4;
			return (uint)result;
		}

		private static uint ParseRawLittleEndian32SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			byte num = ReadRawByte(ref buffer, ref state);
			uint num2 = ReadRawByte(ref buffer, ref state);
			uint num3 = ReadRawByte(ref buffer, ref state);
			uint num4 = ReadRawByte(ref buffer, ref state);
			return num | (num2 << 8) | (num3 << 16) | (num4 << 24);
		}

		public static ulong ParseRawLittleEndian64(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 8 > state.bufferSize)
			{
				return ParseRawLittleEndian64SlowPath(ref buffer, ref state);
			}
			ulong result = BinaryPrimitives.ReadUInt64LittleEndian(buffer.Slice(state.bufferPos, 8));
			state.bufferPos += 8;
			return result;
		}

		private static ulong ParseRawLittleEndian64SlowPath(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			long num = ReadRawByte(ref buffer, ref state);
			ulong num2 = ReadRawByte(ref buffer, ref state);
			ulong num3 = ReadRawByte(ref buffer, ref state);
			ulong num4 = ReadRawByte(ref buffer, ref state);
			ulong num5 = ReadRawByte(ref buffer, ref state);
			ulong num6 = ReadRawByte(ref buffer, ref state);
			ulong num7 = ReadRawByte(ref buffer, ref state);
			ulong num8 = ReadRawByte(ref buffer, ref state);
			return (ulong)num | (num2 << 8) | (num3 << 16) | (num4 << 24) | (num5 << 32) | (num6 << 40) | (num7 << 48) | (num8 << 56);
		}

		public static double ParseDouble(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (!BitConverter.IsLittleEndian || state.bufferPos + 8 > state.bufferSize)
			{
				return BitConverter.Int64BitsToDouble((long)ParseRawLittleEndian64(ref buffer, ref state));
			}
			double result = Unsafe.ReadUnaligned<double>(in MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, 8)));
			state.bufferPos += 8;
			return result;
		}

		public static float ParseFloat(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (!BitConverter.IsLittleEndian || state.bufferPos + 4 > state.bufferSize)
			{
				return ParseFloatSlow(ref buffer, ref state);
			}
			float result = Unsafe.ReadUnaligned<float>(in MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, 4)));
			state.bufferPos += 4;
			return result;
		}

		private unsafe static float ParseFloatSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			byte* pointer = stackalloc byte[4];
			Span<byte> span = new Span<byte>(pointer, 4);
			for (int i = 0; i < 4; i++)
			{
				span[i] = ReadRawByte(ref buffer, ref state);
			}
			if (!BitConverter.IsLittleEndian)
			{
				span.Reverse();
			}
			return Unsafe.ReadUnaligned<float>(in MemoryMarshal.GetReference(span));
		}

		public static byte[] ReadRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
		{
			if (size < 0)
			{
				throw InvalidProtocolBufferException.NegativeSize();
			}
			if (size <= state.bufferSize - state.bufferPos)
			{
				byte[] array = new byte[size];
				buffer.Slice(state.bufferPos, size).CopyTo(array);
				state.bufferPos += size;
				return array;
			}
			return ReadRawBytesSlow(ref buffer, ref state, size);
		}

		private static byte[] ReadRawBytesSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
		{
			ValidateCurrentLimit(ref buffer, ref state, size);
			if ((!state.segmentedBufferHelper.TotalLength.HasValue && size < buffer.Length) || IsDataAvailableInSource(ref state, size))
			{
				byte[] array = new byte[size];
				ReadRawBytesIntoSpan(ref buffer, ref state, size, array);
				return array;
			}
			List<byte[]> list = new List<byte[]>();
			int num = state.bufferSize - state.bufferPos;
			byte[] array2 = new byte[num];
			buffer.Slice(state.bufferPos, num).CopyTo(array2);
			list.Add(array2);
			state.bufferPos = state.bufferSize;
			int num2 = size - num;
			while (num2 > 0)
			{
				state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: true);
				byte[] array3 = new byte[Math.Min(num2, state.bufferSize)];
				buffer.Slice(0, array3.Length).CopyTo(array3);
				state.bufferPos += array3.Length;
				num2 -= array3.Length;
				list.Add(array3);
			}
			byte[] array4 = new byte[size];
			int num3 = 0;
			foreach (byte[] item in list)
			{
				Buffer.BlockCopy(item, 0, array4, num3, item.Length);
				num3 += item.Length;
			}
			return array4;
		}

		public static void SkipRawBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
		{
			if (size < 0)
			{
				throw InvalidProtocolBufferException.NegativeSize();
			}
			ValidateCurrentLimit(ref buffer, ref state, size);
			if (size <= state.bufferSize - state.bufferPos)
			{
				state.bufferPos += size;
				return;
			}
			int num = state.bufferSize - state.bufferPos;
			state.bufferPos = state.bufferSize;
			state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: true);
			while (size - num > state.bufferSize)
			{
				num += state.bufferSize;
				state.bufferPos = state.bufferSize;
				state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: true);
			}
			state.bufferPos = size - num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string ReadString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int length = ParseLength(ref buffer, ref state);
			return ReadRawString(ref buffer, ref state, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ByteString ReadBytes(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int size = ParseLength(ref buffer, ref state);
			return ByteString.AttachBytes(ReadRawBytes(ref buffer, ref state, size));
		}

		[SecuritySafeCritical]
		public unsafe static string ReadRawString(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
		{
			if (length == 0)
			{
				return string.Empty;
			}
			if (length < 0)
			{
				throw InvalidProtocolBufferException.NegativeSize();
			}
			if (length <= state.bufferSize - state.bufferPos)
			{
				string result;
				fixed (byte* reference = &MemoryMarshal.GetReference(buffer.Slice(state.bufferPos, length)))
				{
					result = WritingPrimitives.Utf8Encoding.GetString(reference, length);
				}
				state.bufferPos += length;
				return result;
			}
			return ReadStringSlow(ref buffer, ref state, length);
		}

		private unsafe static string ReadStringSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length)
		{
			ValidateCurrentLimit(ref buffer, ref state, length);
			if (IsDataAvailable(ref state, length))
			{
				byte[] array = null;
				Span<byte> span = ((length > 256) ? ((Span<byte>)(array = ArrayPool<byte>.Shared.Rent(length))) : stackalloc byte[length]);
				Span<byte> span2 = span;
				try
				{
					fixed (byte* reference = &MemoryMarshal.GetReference(span2))
					{
						Span<byte> byteSpan = new Span<byte>(reference, span2.Length);
						ReadRawBytesIntoSpan(ref buffer, ref state, length, byteSpan);
						return WritingPrimitives.Utf8Encoding.GetString(reference, length);
					}
				}
				finally
				{
					if (array != null)
					{
						ArrayPool<byte>.Shared.Return(array);
					}
				}
			}
			return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
		}

		private static void ValidateCurrentLimit(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int size)
		{
			if (state.totalBytesRetired + state.bufferPos + size > state.currentLimit)
			{
				SkipRawBytes(ref buffer, ref state, state.currentLimit - state.totalBytesRetired - state.bufferPos);
				throw InvalidProtocolBufferException.TruncatedMessage();
			}
		}

		[SecuritySafeCritical]
		private static byte ReadRawByte(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos == state.bufferSize)
			{
				state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: true);
			}
			return buffer[state.bufferPos++];
		}

		public static uint ReadRawVarint32(Stream input)
		{
			int num = 0;
			int i;
			for (i = 0; i < 32; i += 7)
			{
				int num2 = input.ReadByte();
				if (num2 == -1)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				num |= (num2 & 0x7F) << i;
				if ((num2 & 0x80) == 0)
				{
					return (uint)num;
				}
			}
			for (; i < 64; i += 7)
			{
				int num3 = input.ReadByte();
				if (num3 == -1)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				if ((num3 & 0x80) == 0)
				{
					return (uint)num;
				}
			}
			throw InvalidProtocolBufferException.MalformedVarint();
		}

		public static int DecodeZigZag32(uint n)
		{
			return (int)((n >> 1) ^ (0 - (n & 1)));
		}

		public static long DecodeZigZag64(ulong n)
		{
			return (long)((n >> 1) ^ (0L - (n & 1)));
		}

		public static bool IsDataAvailable(ref ParserInternalState state, int size)
		{
			if (size <= state.bufferSize - state.bufferPos)
			{
				return true;
			}
			return IsDataAvailableInSource(ref state, size);
		}

		private static bool IsDataAvailableInSource(ref ParserInternalState state, int size)
		{
			return size <= state.segmentedBufferHelper.TotalLength - state.totalBytesRetired - state.bufferPos;
		}

		private static void ReadRawBytesIntoSpan(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, int length, Span<byte> byteSpan)
		{
			int num = length;
			while (num > 0)
			{
				if (state.bufferSize - state.bufferPos == 0)
				{
					state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: true);
				}
				ReadOnlySpan<byte> readOnlySpan = buffer.Slice(state.bufferPos, Math.Min(num, state.bufferSize - state.bufferPos));
				readOnlySpan.CopyTo(byteSpan.Slice(length - num));
				num -= readOnlySpan.Length;
				state.bufferPos += readOnlySpan.Length;
			}
		}
	}
	[SecuritySafeCritical]
	internal static class ParsingPrimitivesMessages
	{
		private static readonly byte[] ZeroLengthMessageStreamData = new byte[1];

		public static void SkipLastField(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.lastTag == 0)
			{
				throw new InvalidOperationException("SkipLastField cannot be called at the end of a stream");
			}
			switch (WireFormat.GetTagWireType(state.lastTag))
			{
			case WireFormat.WireType.StartGroup:
				SkipGroup(ref buffer, ref state, state.lastTag);
				break;
			case WireFormat.WireType.EndGroup:
				throw new InvalidProtocolBufferException("SkipLastField called on an end-group tag, indicating that the corresponding start-group was missing");
			case WireFormat.WireType.Fixed32:
				ParsingPrimitives.ParseRawLittleEndian32(ref buffer, ref state);
				break;
			case WireFormat.WireType.Fixed64:
				ParsingPrimitives.ParseRawLittleEndian64(ref buffer, ref state);
				break;
			case WireFormat.WireType.LengthDelimited:
			{
				int size = ParsingPrimitives.ParseLength(ref buffer, ref state);
				ParsingPrimitives.SkipRawBytes(ref buffer, ref state, size);
				break;
			}
			case WireFormat.WireType.Varint:
				ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
				break;
			}
		}

		public static void SkipGroup(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, uint startGroupTag)
		{
			state.recursionDepth++;
			if (state.recursionDepth >= state.recursionLimit)
			{
				throw InvalidProtocolBufferException.RecursionLimitExceeded();
			}
			uint num;
			while (true)
			{
				num = ParsingPrimitives.ParseTag(ref buffer, ref state);
				if (num == 0)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				if (WireFormat.GetTagWireType(num) == WireFormat.WireType.EndGroup)
				{
					break;
				}
				SkipLastField(ref buffer, ref state);
			}
			int tagFieldNumber = WireFormat.GetTagFieldNumber(startGroupTag);
			int tagFieldNumber2 = WireFormat.GetTagFieldNumber(num);
			if (tagFieldNumber != tagFieldNumber2)
			{
				throw new InvalidProtocolBufferException($"Mismatched end-group tag. Started with field {tagFieldNumber}; ended with field {tagFieldNumber2}");
			}
			state.recursionDepth--;
		}

		public static void ReadMessage(ref ParseContext ctx, IMessage message)
		{
			int byteLimit = ParsingPrimitives.ParseLength(ref ctx.buffer, ref ctx.state);
			if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
			{
				throw InvalidProtocolBufferException.RecursionLimitExceeded();
			}
			int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, byteLimit);
			ctx.state.recursionDepth++;
			ReadRawMessage(ref ctx, message);
			CheckReadEndOfStreamTag(ref ctx.state);
			if (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
			{
				throw InvalidProtocolBufferException.TruncatedMessage();
			}
			ctx.state.recursionDepth--;
			SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
		}

		public static KeyValuePair<TKey, TValue> ReadMapEntry<TKey, TValue>(ref ParseContext ctx, MapField<TKey, TValue>.Codec codec)
		{
			int byteLimit = ParsingPrimitives.ParseLength(ref ctx.buffer, ref ctx.state);
			if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
			{
				throw InvalidProtocolBufferException.RecursionLimitExceeded();
			}
			int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, byteLimit);
			ctx.state.recursionDepth++;
			TKey key = codec.KeyCodec.DefaultValue;
			TValue val = codec.ValueCodec.DefaultValue;
			uint num;
			while ((num = ctx.ReadTag()) != 0)
			{
				if (num == codec.KeyCodec.Tag)
				{
					key = codec.KeyCodec.Read(ref ctx);
				}
				else if (num == codec.ValueCodec.Tag)
				{
					val = codec.ValueCodec.Read(ref ctx);
				}
				else
				{
					SkipLastField(ref ctx.buffer, ref ctx.state);
				}
			}
			if (val == null)
			{
				if (ctx.state.CodedInputStream != null)
				{
					val = codec.ValueCodec.Read(new CodedInputStream(ZeroLengthMessageStreamData));
				}
				else
				{
					ParseContext.Initialize(new ReadOnlySequence<byte>(ZeroLengthMessageStreamData), out var ctx2);
					val = codec.ValueCodec.Read(ref ctx2);
				}
			}
			CheckReadEndOfStreamTag(ref ctx.state);
			if (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
			{
				throw InvalidProtocolBufferException.TruncatedMessage();
			}
			ctx.state.recursionDepth--;
			SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
			return new KeyValuePair<TKey, TValue>(key, val);
		}

		public static void ReadGroup(ref ParseContext ctx, IMessage message)
		{
			if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
			{
				throw InvalidProtocolBufferException.RecursionLimitExceeded();
			}
			ctx.state.recursionDepth++;
			int tagFieldNumber = WireFormat.GetTagFieldNumber(ctx.state.lastTag);
			ReadRawMessage(ref ctx, message);
			CheckLastTagWas(ref ctx.state, WireFormat.MakeTag(tagFieldNumber, WireFormat.WireType.EndGroup));
			ctx.state.recursionDepth--;
		}

		public static void ReadGroup(ref ParseContext ctx, int fieldNumber, UnknownFieldSet set)
		{
			if (ctx.state.recursionDepth >= ctx.state.recursionLimit)
			{
				throw InvalidProtocolBufferException.RecursionLimitExceeded();
			}
			ctx.state.recursionDepth++;
			set.MergeGroupFrom(ref ctx);
			CheckLastTagWas(ref ctx.state, WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup));
			ctx.state.recursionDepth--;
		}

		public static void ReadRawMessage(ref ParseContext ctx, IMessage message)
		{
			if (message is IBufferMessage bufferMessage)
			{
				bufferMessage.InternalMergeFrom(ref ctx);
				return;
			}
			if (ctx.state.CodedInputStream == null)
			{
				throw new InvalidProtocolBufferException("Message " + message.GetType().Name + " doesn't provide the generated method that enables ParseContext-based parsing. You might need to regenerate the generated protobuf code.");
			}
			ctx.CopyStateTo(ctx.state.CodedInputStream);
			try
			{
				message.MergeFrom(ctx.state.CodedInputStream);
			}
			finally
			{
				ctx.LoadStateFrom(ctx.state.CodedInputStream);
			}
		}

		public static void CheckReadEndOfStreamTag(ref ParserInternalState state)
		{
			if (state.lastTag != 0)
			{
				throw InvalidProtocolBufferException.MoreDataAvailable();
			}
		}

		private static void CheckLastTagWas(ref ParserInternalState state, uint expectedTag)
		{
			if (state.lastTag != expectedTag)
			{
				throw InvalidProtocolBufferException.InvalidEndTag();
			}
		}
	}
	[SecuritySafeCritical]
	internal static class ParsingPrimitivesWrappers
	{
		internal static float? ReadFloatWrapperLittleEndian(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 6 <= state.bufferSize)
			{
				switch (buffer[state.bufferPos])
				{
				case 0:
					state.bufferPos++;
					return 0f;
				case 5:
					if (buffer[state.bufferPos + 1] == 13)
					{
						state.bufferPos += 2;
						return ParsingPrimitives.ParseFloat(ref buffer, ref state);
					}
					goto default;
				default:
					return ReadFloatWrapperSlow(ref buffer, ref state);
				}
			}
			return ReadFloatWrapperSlow(ref buffer, ref state);
		}

		internal static float? ReadFloatWrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = ParsingPrimitives.ParseLength(ref buffer, ref state);
			if (num == 0)
			{
				return 0f;
			}
			int num2 = state.totalBytesRetired + state.bufferPos + num;
			float value = 0f;
			do
			{
				if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 13)
				{
					value = ParsingPrimitives.ParseFloat(ref buffer, ref state);
				}
				else
				{
					ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
				}
			}
			while (state.totalBytesRetired + state.bufferPos < num2);
			return value;
		}

		internal static double? ReadDoubleWrapperLittleEndian(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 10 <= state.bufferSize)
			{
				switch (buffer[state.bufferPos])
				{
				case 0:
					state.bufferPos++;
					return 0.0;
				case 9:
					if (buffer[state.bufferPos + 1] == 9)
					{
						state.bufferPos += 2;
						return ParsingPrimitives.ParseDouble(ref buffer, ref state);
					}
					goto default;
				default:
					return ReadDoubleWrapperSlow(ref buffer, ref state);
				}
			}
			return ReadDoubleWrapperSlow(ref buffer, ref state);
		}

		internal static double? ReadDoubleWrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = ParsingPrimitives.ParseLength(ref buffer, ref state);
			if (num == 0)
			{
				return 0.0;
			}
			int num2 = state.totalBytesRetired + state.bufferPos + num;
			double value = 0.0;
			do
			{
				if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 9)
				{
					value = ParsingPrimitives.ParseDouble(ref buffer, ref state);
				}
				else
				{
					ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
				}
			}
			while (state.totalBytesRetired + state.bufferPos < num2);
			return value;
		}

		internal static bool? ReadBoolWrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			return ReadUInt64Wrapper(ref buffer, ref state) != 0;
		}

		internal static uint? ReadUInt32Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 12 <= state.bufferSize)
			{
				int bufferPos = state.bufferPos;
				int num = buffer[state.bufferPos++];
				if (num == 0)
				{
					return 0u;
				}
				if (num >= 128)
				{
					state.bufferPos = bufferPos;
					return ReadUInt32WrapperSlow(ref buffer, ref state);
				}
				int num2 = state.bufferPos + num;
				if (buffer[state.bufferPos++] != 8)
				{
					state.bufferPos = bufferPos;
					return ReadUInt32WrapperSlow(ref buffer, ref state);
				}
				uint value = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
				if (state.bufferPos != num2)
				{
					state.bufferPos = bufferPos;
					return ReadUInt32WrapperSlow(ref buffer, ref state);
				}
				return value;
			}
			return ReadUInt32WrapperSlow(ref buffer, ref state);
		}

		internal static uint? ReadUInt32WrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = ParsingPrimitives.ParseLength(ref buffer, ref state);
			if (num == 0)
			{
				return 0u;
			}
			int num2 = state.totalBytesRetired + state.bufferPos + num;
			uint value = 0u;
			do
			{
				if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 8)
				{
					value = ParsingPrimitives.ParseRawVarint32(ref buffer, ref state);
				}
				else
				{
					ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
				}
			}
			while (state.totalBytesRetired + state.bufferPos < num2);
			return value;
		}

		internal static int? ReadInt32Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			return (int?)ReadUInt32Wrapper(ref buffer, ref state);
		}

		internal static ulong? ReadUInt64Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos + 12 <= state.bufferSize)
			{
				int bufferPos = state.bufferPos;
				int num = buffer[state.bufferPos++];
				if (num == 0)
				{
					return 0uL;
				}
				if (num >= 128)
				{
					state.bufferPos = bufferPos;
					return ReadUInt64WrapperSlow(ref buffer, ref state);
				}
				int num2 = state.bufferPos + num;
				if (buffer[state.bufferPos++] != 8)
				{
					state.bufferPos = bufferPos;
					return ReadUInt64WrapperSlow(ref buffer, ref state);
				}
				ulong value = ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
				if (state.bufferPos != num2)
				{
					state.bufferPos = bufferPos;
					return ReadUInt64WrapperSlow(ref buffer, ref state);
				}
				return value;
			}
			return ReadUInt64WrapperSlow(ref buffer, ref state);
		}

		internal static ulong? ReadUInt64WrapperSlow(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			int num = ParsingPrimitives.ParseLength(ref buffer, ref state);
			if (num == 0)
			{
				return 0uL;
			}
			int num2 = state.totalBytesRetired + state.bufferPos + num;
			ulong value = 0uL;
			do
			{
				if (ParsingPrimitives.ParseTag(ref buffer, ref state) == 8)
				{
					value = ParsingPrimitives.ParseRawVarint64(ref buffer, ref state);
				}
				else
				{
					ParsingPrimitivesMessages.SkipLastField(ref buffer, ref state);
				}
			}
			while (state.totalBytesRetired + state.bufferPos < num2);
			return value;
		}

		internal static long? ReadInt64Wrapper(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			return (long?)ReadUInt64Wrapper(ref buffer, ref state);
		}

		internal static float? ReadFloatWrapperLittleEndian(ref ParseContext ctx)
		{
			return ReadFloatWrapperLittleEndian(ref ctx.buffer, ref ctx.state);
		}

		internal static float? ReadFloatWrapperSlow(ref ParseContext ctx)
		{
			return ReadFloatWrapperSlow(ref ctx.buffer, ref ctx.state);
		}

		internal static double? ReadDoubleWrapperLittleEndian(ref ParseContext ctx)
		{
			return ReadDoubleWrapperLittleEndian(ref ctx.buffer, ref ctx.state);
		}

		internal static double? ReadDoubleWrapperSlow(ref ParseContext ctx)
		{
			return ReadDoubleWrapperSlow(ref ctx.buffer, ref ctx.state);
		}

		internal static bool? ReadBoolWrapper(ref ParseContext ctx)
		{
			return ReadBoolWrapper(ref ctx.buffer, ref ctx.state);
		}

		internal static uint? ReadUInt32Wrapper(ref ParseContext ctx)
		{
			return ReadUInt32Wrapper(ref ctx.buffer, ref ctx.state);
		}

		internal static int? ReadInt32Wrapper(ref ParseContext ctx)
		{
			return ReadInt32Wrapper(ref ctx.buffer, ref ctx.state);
		}

		internal static ulong? ReadUInt64Wrapper(ref ParseContext ctx)
		{
			return ReadUInt64Wrapper(ref ctx.buffer, ref ctx.state);
		}

		internal static ulong? ReadUInt64WrapperSlow(ref ParseContext ctx)
		{
			return ReadUInt64WrapperSlow(ref ctx.buffer, ref ctx.state);
		}

		internal static long? ReadInt64Wrapper(ref ParseContext ctx)
		{
			return ReadInt64Wrapper(ref ctx.buffer, ref ctx.state);
		}
	}
	public static class ProtoPreconditions
	{
		public static T CheckNotNull<T>(T value, string name) where T : class
		{
			if (value == null)
			{
				throw new ArgumentNullException(name);
			}
			return value;
		}

		internal static T CheckNotNullUnconstrained<T>(T value, string name)
		{
			if (value == null)
			{
				throw new ArgumentNullException(name);
			}
			return value;
		}
	}
	[SecuritySafeCritical]
	internal struct SegmentedBufferHelper
	{
		private int? totalLength;

		private ReadOnlySequence<byte>.Enumerator readOnlySequenceEnumerator;

		private CodedInputStream codedInputStream;

		public int? TotalLength => totalLength;

		public CodedInputStream CodedInputStream => codedInputStream;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Initialize(CodedInputStream codedInputStream, out SegmentedBufferHelper instance)
		{
			instance.totalLength = ((codedInputStream.InternalInputStream == null) ? new int?(codedInputStream.InternalBuffer.Length) : ((int?)null));
			instance.readOnlySequenceEnumerator = default(ReadOnlySequence<byte>.Enumerator);
			instance.codedInputStream = codedInputStream;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Initialize(ReadOnlySequence<byte> sequence, out SegmentedBufferHelper instance, out ReadOnlySpan<byte> firstSpan)
		{
			instance.codedInputStream = null;
			ReadOnlyMemory<byte> readOnlyMemory;
			if (sequence.IsSingleSegment)
			{
				readOnlyMemory = sequence.First;
				firstSpan = readOnlyMemory.Span;
				instance.totalLength = firstSpan.Length;
				instance.readOnlySequenceEnumerator = default(ReadOnlySequence<byte>.Enumerator);
			}
			else
			{
				instance.readOnlySequenceEnumerator = sequence.GetEnumerator();
				instance.totalLength = (int)sequence.Length;
				instance.readOnlySequenceEnumerator.MoveNext();
				readOnlyMemory = instance.readOnlySequenceEnumerator.Current;
				firstSpan = readOnlyMemory.Span;
			}
		}

		public bool RefillBuffer(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
		{
			if (codedInputStream != null)
			{
				return RefillFromCodedInputStream(ref buffer, ref state, mustSucceed);
			}
			return RefillFromReadOnlySequence(ref buffer, ref state, mustSucceed);
		}

		public static int PushLimit(ref ParserInternalState state, int byteLimit)
		{
			if (byteLimit < 0)
			{
				throw InvalidProtocolBufferException.NegativeSize();
			}
			byteLimit += state.totalBytesRetired + state.bufferPos;
			int currentLimit = state.currentLimit;
			if (byteLimit > currentLimit)
			{
				throw InvalidProtocolBufferException.TruncatedMessage();
			}
			state.currentLimit = byteLimit;
			RecomputeBufferSizeAfterLimit(ref state);
			return currentLimit;
		}

		public static void PopLimit(ref ParserInternalState state, int oldLimit)
		{
			state.currentLimit = oldLimit;
			RecomputeBufferSizeAfterLimit(ref state);
		}

		public static bool IsReachedLimit(ref ParserInternalState state)
		{
			if (state.currentLimit == int.MaxValue)
			{
				return false;
			}
			return state.totalBytesRetired + state.bufferPos >= state.currentLimit;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsAtEnd(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state)
		{
			if (state.bufferPos == state.bufferSize)
			{
				return !state.segmentedBufferHelper.RefillBuffer(ref buffer, ref state, mustSucceed: false);
			}
			return false;
		}

		private bool RefillFromReadOnlySequence(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
		{
			CheckCurrentBufferIsEmpty(ref state);
			if (state.totalBytesRetired + state.bufferSize == state.currentLimit)
			{
				if (mustSucceed)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				return false;
			}
			state.totalBytesRetired += state.bufferSize;
			state.bufferPos = 0;
			state.bufferSize = 0;
			while (readOnlySequenceEnumerator.MoveNext())
			{
				buffer = readOnlySequenceEnumerator.Current.Span;
				state.bufferSize = buffer.Length;
				if (buffer.Length != 0)
				{
					break;
				}
			}
			if (state.bufferSize == 0)
			{
				if (mustSucceed)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				return false;
			}
			RecomputeBufferSizeAfterLimit(ref state);
			int num = state.totalBytesRetired + state.bufferSize + state.bufferSizeAfterLimit;
			if (num < 0 || num > state.sizeLimit)
			{
				throw InvalidProtocolBufferException.SizeLimitExceeded();
			}
			return true;
		}

		private bool RefillFromCodedInputStream(ref ReadOnlySpan<byte> buffer, ref ParserInternalState state, bool mustSucceed)
		{
			CheckCurrentBufferIsEmpty(ref state);
			if (state.totalBytesRetired + state.bufferSize == state.currentLimit)
			{
				if (mustSucceed)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				return false;
			}
			Stream internalInputStream = codedInputStream.InternalInputStream;
			state.totalBytesRetired += state.bufferSize;
			state.bufferPos = 0;
			state.bufferSize = internalInputStream?.Read(codedInputStream.InternalBuffer, 0, buffer.Length) ?? 0;
			if (state.bufferSize < 0)
			{
				throw new InvalidOperationException("Stream.Read returned a negative count");
			}
			if (state.bufferSize == 0)
			{
				if (mustSucceed)
				{
					throw InvalidProtocolBufferException.TruncatedMessage();
				}
				return false;
			}
			RecomputeBufferSizeAfterLimit(ref state);
			int num = state.totalBytesRetired + state.bufferSize + state.bufferSizeAfterLimit;
			if (num < 0 || num > state.sizeLimit)
			{
				throw InvalidProtocolBufferException.SizeLimitExceeded();
			}
			return true;
		}

		private static void RecomputeBufferSizeAfterLimit(ref ParserInternalState state)
		{
			state.bufferSize += state.bufferSizeAfterLimit;
			int num = state.totalBytesRetired + state.bufferSize;
			if (num > state.currentLimit)
			{
				state.bufferSizeAfterLimit = num - state.currentLimit;
				state.bufferSize -= state.bufferSizeAfterLimit;
			}
			else
			{
				state.bufferSizeAfterLimit = 0;
			}
		}

		private static void CheckCurrentBufferIsEmpty(ref ParserInternalState state)
		{
			if (state.bufferPos < state.bufferSize)
			{
				throw new InvalidOperationException("RefillBuffer() called when buffer wasn't empty.");
			}
		}
	}
	internal sealed class UnknownField
	{
		private List<ulong> varintList;

		private List<uint> fixed32List;

		private List<ulong> fixed64List;

		private List<ByteString> lengthDelimitedList;

		private List<UnknownFieldSet> groupList;

		public override bool Equals(object other)
		{
			if (this == other)
			{
				return true;
			}
			if (other is UnknownField unknownField && Lists.Equals(varintList, unknownField.varintList) && Lists.Equals(fixed32List, unknownField.fixed32List) && Lists.Equals(fixed64List, unknownField.fixed64List) && Lists.Equals(lengthDelimitedList, unknownField.lengthDelimitedList))
			{
				return Lists.Equals(groupList, unknownField.groupList);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((((43 * 47 + Lists.GetHashCode(varintList)) * 47 + Lists.GetHashCode(fixed32List)) * 47 + Lists.GetHashCode(fixed64List)) * 47 + Lists.GetHashCode(lengthDelimitedList)) * 47 + Lists.GetHashCode(groupList);
		}

		internal void WriteTo(int fieldNumber, ref WriteContext output)
		{
			if (varintList != null)
			{
				foreach (ulong varint in varintList)
				{
					output.WriteTag(fieldNumber, WireFormat.WireType.Varint);
					output.WriteUInt64(varint);
				}
			}
			if (fixed32List != null)
			{
				foreach (uint @fixed in fixed32List)
				{
					output.WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
					output.WriteFixed32(@fixed);
				}
			}
			if (fixed64List != null)
			{
				foreach (ulong fixed2 in fixed64List)
				{
					output.WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
					output.WriteFixed64(fixed2);
				}
			}
			if (lengthDelimitedList != null)
			{
				foreach (ByteString lengthDelimited in lengthDelimitedList)
				{
					output.WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
					output.WriteBytes(lengthDelimited);
				}
			}
			if (groupList == null)
			{
				return;
			}
			foreach (UnknownFieldSet group in groupList)
			{
				output.WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
				group.WriteTo(ref output);
				output.WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
			}
		}

		internal int GetSerializedSize(int fieldNumber)
		{
			int num = 0;
			if (varintList != null)
			{
				num += CodedOutputStream.ComputeTagSize(fieldNumber) * varintList.Count;
				foreach (ulong varint in varintList)
				{
					num += CodedOutputStream.ComputeUInt64Size(varint);
				}
			}
			if (fixed32List != null)
			{
				num += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed32List.Count;
				num += CodedOutputStream.ComputeFixed32Size(1u) * fixed32List.Count;
			}
			if (fixed64List != null)
			{
				num += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed64List.Count;
				num += CodedOutputStream.ComputeFixed64Size(1uL) * fixed64List.Count;
			}
			if (lengthDelimitedList != null)
			{
				num += CodedOutputStream.ComputeTagSize(fieldNumber) * lengthDelimitedList.Count;
				foreach (ByteString lengthDelimited in lengthDelimitedList)
				{
					num += CodedOutputStream.ComputeBytesSize(lengthDelimited);
				}
			}
			if (groupList != null)
			{
				num += CodedOutputStream.ComputeTagSize(fieldNumber) * 2 * groupList.Count;
				foreach (UnknownFieldSet group in groupList)
				{
					num += group.CalculateSize();
				}
			}
			return num;
		}

		internal UnknownField MergeFrom(UnknownField other)
		{
			varintList = AddAll(varintList, other.varintList);
			fixed32List = AddAll(fixed32List, other.fixed32List);
			fixed64List = AddAll(fixed64List, other.fixed64List);
			lengthDelimitedList = AddAll(lengthDelimitedList, other.lengthDelimitedList);
			groupList = AddAll(groupList, other.groupList);
			return this;
		}

		private static List<T> AddAll<T>(List<T> current, IList<T> extras)
		{
			if (extras == null || extras.Count == 0)
			{
				return current;
			}
			if (current == null)
			{
				current = new List<T>(extras);
			}
			else
			{
				current.AddRange(extras);
			}
			return current;
		}

		internal UnknownField AddVarint(ulong value)
		{
			varintList = Add(varintList, value);
			return this;
		}

		internal UnknownField AddFixed32(uint value)
		{
			fixed32List = Add(fixed32List, value);
			return this;
		}

		internal UnknownField AddFixed64(ulong value)
		{
			fixed64List = Add(fixed64List, value);
			return this;
		}

		internal UnknownField AddLengthDelimited(ByteString value)
		{
			lengthDelimitedList = Add(lengthDelimitedList, value);
			return this;
		}

		internal UnknownField AddGroup(UnknownFieldSet value)
		{
			groupList = Add(groupList, value);
			return this;
		}

		private static List<T> Add<T>(List<T> list, T value)
		{
			if (list == null)
			{
				list = new List<T>();
			}
			list.Add(value);
			return list;
		}
	}
	public sealed class UnknownFieldSet
	{
		private readonly IDictionary<int, UnknownField> fields;

		private int lastFieldNumber;

		private UnknownField lastField;

		internal UnknownFieldSet()
		{
			fields = new Dictionary<int, UnknownField>();
		}

		internal bool HasField(int field)
		{
			return fields.ContainsKey(field);
		}

		public void WriteTo(CodedOutputStream output)
		{
			WriteContext.Initialize(output, out var ctx);
			try
			{
				WriteTo(ref ctx);
			}
			finally
			{
				ctx.CopyStateTo(output);
			}
		}

		[SecuritySafeCritical]
		public void WriteTo(ref WriteContext ctx)
		{
			foreach (KeyValuePair<int, UnknownField> field in fields)
			{
				field.Value.WriteTo(field.Key, ref ctx);
			}
		}

		public int CalculateSize()
		{
			int num = 0;
			foreach (KeyValuePair<int, UnknownField> field in fields)
			{
				num += field.Value.GetSerializedSize(field.Key);
			}
			return num;
		}

		public override bool Equals(object other)
		{
			if (this == other)
			{
				return true;
			}
			IDictionary<int, UnknownField> dictionary = (other as UnknownFieldSet).fields;
			if (fields.Count != dictionary.Count)
			{
				return false;
			}
			foreach (KeyValuePair<int, UnknownField> field in fields)
			{
				if (!dictionary.TryGetValue(field.Key, out var value))
				{
					return false;
				}
				if (!field.Value.Equals(value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = 1;
			foreach (KeyValuePair<int, UnknownField> field in fields)
			{
				int num2 = field.Key.GetHashCode() ^ field.Value.GetHashCode();
				num ^= num2;
			}
			return num;
		}

		private UnknownField GetOrAddField(int number)
		{
			if (lastField != null && number == lastFieldNumber)
			{
				return lastField;
			}
			if (number == 0)
			{
				return null;
			}
			if (fields.TryGetValue(number, out var value))
			{
				return value;
			}
			lastField = new UnknownField();
			AddOrReplaceField(number, lastField);
			lastFieldNumber = number;
			return lastField;
		}

		internal UnknownFieldSet AddOrReplaceField(int number, UnknownField field)
		{
			if (number == 0)
			{
				throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number.");
			}
			fields[number] = field;
			return this;
		}

		private bool MergeFieldFrom(ref ParseContext ctx)
		{
			uint lastTag = ctx.LastTag;
			int tagFieldNumber = WireFormat.GetTagFieldNumber(lastTag);
			switch (WireFormat.GetTagWireType(lastTag))
			{
			case WireFormat.WireType.Varint:
			{
				ulong value4 = ctx.ReadUInt64();
				GetOrAddField(tagFieldNumber).AddVarint(value4);
				return true;
			}
			case WireFormat.WireType.Fixed32:
			{
				uint value3 = ctx.ReadFixed32();
				GetOrAddField(tagFieldNumber).AddFixed32(value3);
				return true;
			}
			case WireFormat.WireType.Fixed64:
			{
				ulong value2 = ctx.ReadFixed64();
				GetOrAddField(tagFieldNumber).AddFixed64(value2);
				return true;
			}
			case WireFormat.WireType.LengthDelimited:
			{
				ByteString value = ctx.ReadBytes();
				GetOrAddField(tagFieldNumber).AddLengthDelimited(value);
				return true;
			}
			case WireFormat.WireType.StartGroup:
			{
				UnknownFieldSet unknownFieldSet = new UnknownFieldSet();
				ParsingPrimitivesMessages.ReadGroup(ref ctx, tagFieldNumber, unknownFieldSet);
				GetOrAddField(tagFieldNumber).AddGroup(unknownFieldSet);
				return true;
			}
			case WireFormat.WireType.EndGroup:
				return false;
			default:
				throw InvalidProtocolBufferException.InvalidWireType();
			}
		}

		internal void MergeGroupFrom(ref ParseContext ctx)
		{
			while (ctx.ReadTag() != 0 && MergeFieldFrom(ref ctx))
			{
			}
		}

		public static UnknownFieldSet MergeFieldFrom(UnknownFieldSet unknownFields, CodedInputStream input)
		{
			ParseContext.Initialize(input, out var ctx);
			try
			{
				return MergeFieldFrom(unknownFields, ref ctx);
			}
			finally
			{
				ctx.CopyStateTo(input);
			}
		}

		[SecuritySafeCritical]
		public static UnknownFieldSet MergeFieldFrom(UnknownFieldSet unknownFields, ref ParseContext ctx)
		{
			if (ctx.DiscardUnknownFields)
			{
				ParsingPrimitivesMessages.SkipLastField(ref ctx.buffer, ref ctx.state);
				return unknownFields;
			}
			if (unknownFields == null)
			{
				unknownFields = new UnknownFieldSet();
			}
			if (!unknownFields.MergeFieldFrom(ref ctx))
			{
				throw new InvalidProtocolBufferException("Merge an unknown field of end-group tag, indicating that the corresponding start-group was missing.");
			}
			return unknownFields;
		}

		private UnknownFieldSet MergeFrom(UnknownFieldSet other)
		{
			if (other != null)
			{
				foreach (KeyValuePair<int, UnknownField> field in other.fields)
				{
					MergeField(field.Key, field.Value);
				}
			}
			return this;
		}

		public static UnknownFieldSet MergeFrom(UnknownFieldSet unknownFields, UnknownFieldSet other)
		{
			if (other == null)
			{
				return unknownFields;
			}
			if (unknownFields == null)
			{
				unknownFields = new UnknownFieldSet();
			}
			unknownFields.MergeFrom(other);
			return unknownFields;
		}

		private UnknownFieldSet MergeField(int number, UnknownField field)
		{
			if (number == 0)
			{
				throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number.");
			}
			if (HasField(number))
			{
				GetOrAddField(number).MergeFrom(field);
			}
			else
			{
				AddOrReplaceField(number, field);
			}
			return this;
		}

		public static UnknownFieldSet Clone(UnknownFieldSet other)
		{
			if (other == null)
			{
				return null;
			}
			UnknownFieldSet unknownFieldSet = new UnknownFieldSet();
			unknownFieldSet.MergeFrom(other);
			return unknownFieldSet;
		}
	}
	[SecuritySafeCritical]
	public static class UnsafeByteOperations
	{
		public static ByteString UnsafeWrap(ReadOnlyMemory<byte> bytes)
		{
			return ByteString.AttachBytes(bytes);
		}
	}
	public static class WireFormat
	{
		public enum WireType : uint
		{
			Varint,
			Fixed64,
			LengthDelimited,
			StartGroup,
			EndGroup,
			Fixed32
		}

		private const int TagTypeBits = 3;

		private const uint TagTypeMask = 7u;

		public static WireType GetTagWireType(uint tag)
		{
			return (WireType)(tag & 7);
		}

		public static int GetTagFieldNumber(uint tag)
		{
			return (int)(tag >> 3);
		}

		public static uint MakeTag(int fieldNumber, WireType wireType)
		{
			return (uint)(fieldNumber << 3) | (uint)wireType;
		}
	}
	[SecuritySafeCritical]
	internal struct WriteBufferHelper
	{
		private IBufferWriter<byte> bufferWriter;

		private CodedOutputStream codedOutputStream;

		public CodedOutputStream CodedOutputStream => codedOutputStream;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Initialize(CodedOutputStream codedOutputStream, out WriteBufferHelper instance)
		{
			instance.bufferWriter = null;
			instance.codedOutputStream = codedOutputStream;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Initialize(IBufferWriter<byte> bufferWriter, out WriteBufferHelper instance, out Span<byte> buffer)
		{
			instance.bufferWriter = bufferWriter;
			instance.codedOutputStream = null;
			buffer = default(Span<byte>);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void InitializeNonRefreshable(out WriteBufferHelper instance)
		{
			instance.bufferWriter = null;
			instance.codedOutputStream = null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CheckNoSpaceLeft(ref WriterInternalState state)
		{
			if (GetSpaceLeft(ref state) != 0)
			{
				throw new InvalidOperationException("Did not write as much data as expected.");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetSpaceLeft(ref WriterInternalState state)
		{
			if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream == null && state.writeBufferHelper.bufferWriter == null)
			{
				return state.limit - state.position;
			}
			throw new InvalidOperationException("SpaceLeft can only be called on CodedOutputStreams that are writing to a flat array or when writing to a single span.");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void RefreshBuffer(ref Span<byte> buffer, ref WriterInternalState state)
		{
			if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
			{
				state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
				state.position = 0;
				return;
			}
			if (state.writeBufferHelper.bufferWriter != null)
			{
				state.writeBufferHelper.bufferWriter.Advance(state.position);
				state.position = 0;
				buffer = state.writeBufferHelper.bufferWriter.GetSpan();
				state.limit = buffer.Length;
				return;
			}
			throw new CodedOutputStream.OutOfSpaceException();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Flush(ref Span<byte> buffer, ref WriterInternalState state)
		{
			if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
			{
				state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
				state.position = 0;
			}
			else if (state.writeBufferHelper.bufferWriter != null)
			{
				state.writeBufferHelper.bufferWriter.Advance(state.position);
				state.position = 0;
				state.limit = 0;
				buffer = default(Span<byte>);
			}
		}
	}
	[SecuritySafeCritical]
	public ref struct WriteContext
	{
		internal Span<byte> buffer;

		internal WriterInternalState state;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ref Span<byte> buffer, ref WriterInternalState state, out WriteContext ctx)
		{
			ctx.buffer = buffer;
			ctx.state = state;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(CodedOutputStream output, out WriteContext ctx)
		{
			ctx.buffer = new Span<byte>(output.InternalBuffer);
			ctx.state = output.InternalState;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(IBufferWriter<byte> output, out WriteContext ctx)
		{
			ctx.buffer = default(Span<byte>);
			ctx.state = default(WriterInternalState);
			WriteBufferHelper.Initialize(output, out ctx.state.writeBufferHelper, out ctx.buffer);
			ctx.state.limit = ctx.buffer.Length;
			ctx.state.position = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Initialize(ref Span<byte> buffer, out WriteContext ctx)
		{
			ctx.buffer = buffer;
			ctx.state = default(WriterInternalState);
			ctx.state.limit = ctx.buffer.Length;
			ctx.state.position = 0;
			WriteBufferHelper.InitializeNonRefreshable(out ctx.state.writeBufferHelper);
		}

		public void WriteDouble(double value)
		{
			WritingPrimitives.WriteDouble(ref buffer, ref state, value);
		}

		public void WriteFloat(float value)
		{
			WritingPrimitives.WriteFloat(ref buffer, ref state, value);
		}

		public void WriteUInt64(ulong value)
		{
			WritingPrimitives.WriteUInt64(ref buffer, ref state, value);
		}

		public void WriteInt64(long value)
		{
			WritingPrimitives.WriteInt64(ref buffer, ref state, value);
		}

		public void WriteInt32(int value)
		{
			WritingPrimitives.WriteInt32(ref buffer, ref state, value);
		}

		public void WriteFixed64(ulong value)
		{
			WritingPrimitives.WriteFixed64(ref buffer, ref state, value);
		}

		public void WriteFixed32(uint value)
		{
			WritingPrimitives.WriteFixed32(ref buffer, ref state, value);
		}

		public void WriteBool(bool value)
		{
			WritingPrimitives.WriteBool(ref buffer, ref state, value);
		}

		public void WriteString(string value)
		{
			WritingPrimitives.WriteString(ref buffer, ref state, value);
		}

		public void WriteMessage(IMessage value)
		{
			WritingPrimitivesMessages.WriteMessage(ref this, value);
		}

		public void WriteGroup(IMessage value)
		{
			WritingPrimitivesMessages.WriteGroup(ref this, value);
		}

		public void WriteBytes(ByteString value)
		{
			WritingPrimitives.WriteBytes(ref buffer, ref state, value);
		}

		public void WriteUInt32(uint value)
		{
			WritingPrimitives.WriteUInt32(ref buffer, ref state, value);
		}

		public void WriteEnum(int value)
		{
			WritingPrimitives.WriteEnum(ref buffer, ref state, value);
		}

		public void WriteSFixed32(int value)
		{
			WritingPrimitives.WriteSFixed32(ref buffer, ref state, value);
		}

		public void WriteSFixed64(long value)
		{
			WritingPrimitives.WriteSFixed64(ref buffer, ref state, value);
		}

		public void WriteSInt32(int value)
		{
			WritingPrimitives.WriteSInt32(ref buffer, ref state, value);
		}

		public void WriteSInt64(long value)
		{
			WritingPrimitives.WriteSInt64(ref buffer, ref state, value);
		}

		public void WriteLength(int length)
		{
			WritingPrimitives.WriteLength(ref buffer, ref state, length);
		}

		public void WriteTag(int fieldNumber, WireFormat.WireType type)
		{
			WritingPrimitives.WriteTag(ref buffer, ref state, fieldNumber, type);
		}

		public void WriteTag(uint tag)
		{
			WritingPrimitives.WriteTag(ref buffer, ref state, tag);
		}

		public void WriteRawTag(byte b1)
		{
			WritingPrimitives.WriteRawTag(ref buffer, ref state, b1);
		}

		public void WriteRawTag(byte b1, byte b2)
		{
			WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3)
		{
			WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
		{
			WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4);
		}

		public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
		{
			WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4, b5);
		}

		internal void Flush()
		{
			WriteBufferHelper.Flush(ref buffer, ref state);
		}

		internal void CheckNoSpaceLeft()
		{
			WriteBufferHelper.CheckNoSpaceLeft(ref state);
		}

		internal void CopyStateTo(CodedOutputStream output)
		{
			output.InternalState = state;
		}

		internal void LoadStateFrom(CodedOutputStream output)
		{
			state = output.InternalState;
		}
	}
	internal struct WriterInternalState
	{
		internal int limit;

		internal int position;

		internal WriteBufferHelper writeBufferHelper;

		internal CodedOutputStream CodedOutputStream => writeBufferHelper.CodedOutputStream;
	}
	[SecuritySafeCritical]
	internal static class WritingPrimitives
	{
		internal static readonly Encoding Utf8Encoding = Encoding.UTF8;

		public static void WriteDouble(ref Span<byte> buffer, ref WriterInternalState state, double value)
		{
			WriteRawLittleEndian64(ref buffer, ref state, (ulong)BitConverter.DoubleToInt64Bits(value));
		}

		public static void WriteFloat(ref Span<byte> buffer, ref WriterInternalState state, float value)
		{
			if (buffer.Length - state.position >= 4)
			{
				Span<byte> span = buffer.Slice(state.position, 4);
				Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(span), value);
				if (!BitConverter.IsLittleEndian)
				{
					span.Reverse();
				}
				state.position += 4;
			}
			else
			{
				WriteFloatSlowPath(ref buffer, ref state, value);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteFloatSlowPath(ref Span<byte> buffer, ref WriterInternalState state, float value)
		{
			Span<byte> span = stackalloc byte[4];
			Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(span), value);
			if (!BitConverter.IsLittleEndian)
			{
				span.Reverse();
			}
			WriteRawByte(ref buffer, ref state, span[0]);
			WriteRawByte(ref buffer, ref state, span[1]);
			WriteRawByte(ref buffer, ref state, span[2]);
			WriteRawByte(ref buffer, ref state, span[3]);
		}

		public static void WriteUInt64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
		{
			WriteRawVarint64(ref buffer, ref state, value);
		}

		public static void WriteInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
		{
			WriteRawVarint64(ref buffer, ref state, (ulong)value);
		}

		public static void WriteInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
		{
			if (value >= 0)
			{
				WriteRawVarint32(ref buffer, ref state, (uint)value);
			}
			else
			{
				WriteRawVarint64(ref buffer, ref state, (ulong)value);
			}
		}

		public static void WriteFixed64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
		{
			WriteRawLittleEndian64(ref buffer, ref state, value);
		}

		public static void WriteFixed32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
		{
			WriteRawLittleEndian32(ref buffer, ref state, value);
		}

		public static void WriteBool(ref Span<byte> buffer, ref WriterInternalState state, bool value)
		{
			WriteRawByte(ref buffer, ref state, (byte)(value ? 1 : 0));
		}

		public static void WriteString(ref Span<byte> buffer, ref WriterInternalState state, string value)
		{
			if (value.Length <= 42 && buffer.Length - state.position - 1 >= value.Length * 3)
			{
				buffer[state.position++] = (byte)WriteStringToBuffer(buffer, ref state, value);
				return;
			}
			int byteCount = Utf8Encoding.GetByteCount(value);
			WriteLength(ref buffer, ref state, byteCount);
			if (buffer.Length - state.position >= byteCount)
			{
				if (byteCount == value.Length)
				{
					WriteAsciiStringToBuffer(buffer, ref state, value, byteCount);
				}
				else
				{
					WriteStringToBuffer(buffer, ref state, value);
				}
			}
			else
			{
				byte[] bytes = Utf8Encoding.GetBytes(value);
				WriteRawBytes(ref buffer, ref state, bytes);
			}
		}

		private static void WriteAsciiStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value, int length)
		{
			ref char reference = ref MemoryMarshal.GetReference(value.AsSpan());
			ref byte reference2 = ref MemoryMarshal.GetReference(buffer.Slice(state.position));
			int i = 0;
			if (IntPtr.Size == 8 && length >= 4)
			{
				ref byte source = ref Unsafe.As<char, byte>(ref reference);
				int num = value.Length - 4;
				do
				{
					NarrowFourUtf16CharsToAsciiAndWriteToBuffer(ref Unsafe.AddByteOffset(ref reference2, (IntPtr)i), Unsafe.ReadUnaligned<ulong>(in Unsafe.AddByteOffset(ref source, (IntPtr)(i * 2))));
				}
				while ((i += 4) <= num);
			}
			for (; i < length; i++)
			{
				Unsafe.AddByteOffset(ref reference2, (IntPtr)i) = (byte)Unsafe.AddByteOffset(ref reference, (IntPtr)(i * 2));
			}
			state.position += length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void NarrowFourUtf16CharsToAsciiAndWriteToBuffer(ref byte outputBuffer, ulong value)
		{
			if (BitConverter.IsLittleEndian)
			{
				outputBuffer = (byte)value;
				value >>= 16;
				Unsafe.Add(ref outputBuffer, 1) = (byte)value;
				value >>= 16;
				Unsafe.Add(ref outputBuffer, 2) = (byte)value;
				value >>= 16;
				Unsafe.Add(ref outputBuffer, 3) = (byte)value;
			}
			else
			{
				Unsafe.Add(ref outputBuffer, 3) = (byte)value;
				value >>= 16;
				Unsafe.Add(ref outputBuffer, 2) = (byte)value;
				value >>= 16;
				Unsafe.Add(ref outputBuffer, 1) = (byte)value;
				value >>= 16;
				outputBuffer = (byte)value;
			}
		}

		private unsafe static int WriteStringToBuffer(Span<byte> buffer, ref WriterInternalState state, string value)
		{
			ReadOnlySpan<char> span = value.AsSpan();
			int bytes;
			fixed (char* reference = &MemoryMarshal.GetReference(span))
			{
				fixed (byte* reference2 = &MemoryMarshal.GetReference(buffer))
				{
					bytes = Utf8Encoding.GetBytes(reference, span.Length, reference2 + state.position, buffer.Length - state.position);
				}
			}
			state.position += bytes;
			return bytes;
		}

		public static void WriteBytes(ref Span<byte> buffer, ref WriterInternalState state, ByteString value)
		{
			WriteLength(ref buffer, ref state, value.Length);
			WriteRawBytes(ref buffer, ref state, value.Span);
		}

		public static void WriteUInt32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
		{
			WriteRawVarint32(ref buffer, ref state, value);
		}

		public static void WriteEnum(ref Span<byte> buffer, ref WriterInternalState state, int value)
		{
			WriteInt32(ref buffer, ref state, value);
		}

		public static void WriteSFixed32(ref Span<byte> buffer, ref WriterInternalState state, int value)
		{
			WriteRawLittleEndian32(ref buffer, ref state, (uint)value);
		}

		public static void WriteSFixed64(ref Span<byte> buffer, ref WriterInternalState state, long value)
		{
			WriteRawLittleEndian64(ref buffer, ref state, (ulong)value);
		}

		public static void WriteSInt32(ref Span<byte> buffer, ref WriterInternalState state, int value)
		{
			WriteRawVarint32(ref buffer, ref state, EncodeZigZag32(value));
		}

		public static void WriteSInt64(ref Span<byte> buffer, ref WriterInternalState state, long value)
		{
			WriteRawVarint64(ref buffer, ref state, EncodeZigZag64(value));
		}

		public static void WriteLength(ref Span<byte> buffer, ref WriterInternalState state, int length)
		{
			WriteRawVarint32(ref buffer, ref state, (uint)length);
		}

		public static void WriteRawVarint32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
		{
			if (value < 128 && state.position < buffer.Length)
			{
				buffer[state.position++] = (byte)value;
				return;
			}
			while (state.position < buffer.Length)
			{
				if (value > 127)
				{
					buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
					value >>= 7;
					continue;
				}
				buffer[state.position++] = (byte)value;
				return;
			}
			while (value > 127)
			{
				WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
				value >>= 7;
			}
			WriteRawByte(ref buffer, ref state, (byte)value);
		}

		public static void WriteRawVarint64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
		{
			if (value < 128 && state.position < buffer.Length)
			{
				buffer[state.position++] = (byte)value;
				return;
			}
			while (state.position < buffer.Length)
			{
				if (value > 127)
				{
					buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
					value >>= 7;
					continue;
				}
				buffer[state.position++] = (byte)value;
				return;
			}
			while (value > 127)
			{
				WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
				value >>= 7;
			}
			WriteRawByte(ref buffer, ref state, (byte)value);
		}

		public static void WriteRawLittleEndian32(ref Span<byte> buffer, ref WriterInternalState state, uint value)
		{
			if (state.position + 4 > buffer.Length)
			{
				WriteRawLittleEndian32SlowPath(ref buffer, ref state, value);
				return;
			}
			BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(state.position), value);
			state.position += 4;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteRawLittleEndian32SlowPath(ref Span<byte> buffer, ref WriterInternalState state, uint value)
		{
			WriteRawByte(ref buffer, ref state, (byte)value);
			WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
		}

		public static void WriteRawLittleEndian64(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
		{
			if (state.position + 8 > buffer.Length)
			{
				WriteRawLittleEndian64SlowPath(ref buffer, ref state, value);
				return;
			}
			BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(state.position), value);
			state.position += 8;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void WriteRawLittleEndian64SlowPath(ref Span<byte> buffer, ref WriterInternalState state, ulong value)
		{
			WriteRawByte(ref buffer, ref state, (byte)value);
			WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 32));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 40));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 48));
			WriteRawByte(ref buffer, ref state, (byte)(value >> 56));
		}

		private static void WriteRawByte(ref Span<byte> buffer, ref WriterInternalState state, byte value)
		{
			if (state.position == buffer.Length)
			{
				WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
			}
			buffer[state.position++] = value;
		}

		public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value)
		{
			WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value));
		}

		public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, byte[] value, int offset, int length)
		{
			WriteRawBytes(ref buffer, ref state, new ReadOnlySpan<byte>(value, offset, length));
		}

		public static void WriteRawBytes(ref Span<byte> buffer, ref WriterInternalState state, ReadOnlySpan<byte> value)
		{
			if (buffer.Length - state.position >= value.Length)
			{
				value.CopyTo(buffer.Slice(state.position, value.Length));
				state.position += value.Length;
				return;
			}
			int num = 0;
			while (buffer.Length - state.position < value.Length - num)
			{
				int num2 = buffer.Length - state.position;
				value.Slice(num, num2).CopyTo(buffer.Slice(state.position, num2));
				num += num2;
				state.position += num2;
				WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
			}
			int num3 = value.Length - num;
			value.Slice(num, num3).CopyTo(buffer.Slice(state.position, num3));
			state.position += num3;
		}

		public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, int fieldNumber, WireFormat.WireType type)
		{
			WriteRawVarint32(ref buffer, ref state, WireFormat.MakeTag(fieldNumber, type));
		}

		public static void WriteTag(ref Span<byte> buffer, ref WriterInternalState state, uint tag)
		{
			WriteRawVarint32(ref buffer, ref state, tag);
		}

		public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1)
		{
			WriteRawByte(ref buffer, ref state, b1);
		}

		public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
		{
			if (state.position + 2 > buffer.Length)
			{
				WriteRawTagSlowPath(ref buffer, ref state, b1, b2);
				return;
			}
			buffer[state.position++] = b1;
			buffer[state.position++] = b2;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2)
		{
			WriteRawByte(ref buffer, ref state, b1);
			WriteRawByte(ref buffer, ref state, b2);
		}

		public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
		{
			if (state.position + 3 > buffer.Length)
			{
				WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3);
				return;
			}
			buffer[state.position++] = b1;
			buffer[state.position++] = b2;
			buffer[state.position++] = b3;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
		{
			WriteRawByte(ref buffer, ref state, b1);
			WriteRawByte(ref buffer, ref state, b2);
			WriteRawByte(ref buffer, ref state, b3);
		}

		public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
		{
			if (state.position + 4 > buffer.Length)
			{
				WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4);
				return;
			}
			buffer[state.position++] = b1;
			buffer[state.position++] = b2;
			buffer[state.position++] = b3;
			buffer[state.position++] = b4;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
		{
			WriteRawByte(ref buffer, ref state, b1);
			WriteRawByte(ref buffer, ref state, b2);
			WriteRawByte(ref buffer, ref state, b3);
			WriteRawByte(ref buffer, ref state, b4);
		}

		public static void WriteRawTag(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
		{
			if (state.position + 5 > buffer.Length)
			{
				WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4, b5);
				return;
			}
			buffer[state.position++] = b1;
			buffer[state.position++] = b2;
			buffer[state.position++] = b3;
			buffer[state.position++] = b4;
			buffer[state.position++] = b5;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void WriteRawTagSlowPath(ref Span<byte> buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
		{
			WriteRawByte(ref buffer, ref state, b1);
			WriteRawByte(ref buffer, ref state, b2);
			WriteRawByte(ref buffer, ref state, b3);
			WriteRawByte(ref buffer, ref state, b4);
			WriteRawByte(ref buffer, ref state, b5);
		}

		public static uint EncodeZigZag32(int n)
		{
			return (uint)((n << 1) ^ (n >> 31));
		}

		public static ulong EncodeZigZag64(long n)
		{
			return (ulong)((n << 1) ^ (n >> 63));
		}
	}
	[SecuritySafeCritical]
	internal static class WritingPrimitivesMessages
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteMessage(ref WriteContext ctx, IMessage value)
		{
			WritingPrimitives.WriteLength(ref ctx.buffer, ref ctx.state, value.CalculateSize());
			WriteRawMessage(ref ctx, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteGroup(ref WriteContext ctx, IMessage value)
		{
			WriteRawMessage(ref ctx, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteRawMessage(ref WriteContext ctx, IMessage message)
		{
			if (message is IBufferMessage bufferMessage)
			{
				bufferMessage.InternalWriteTo(ref ctx);
				return;
			}
			if (ctx.state.CodedOutputStream == null)
			{
				throw new InvalidProtocolBufferException("Message " + message.GetType().Name + " doesn't provide the generated method that enables WriteContext-based serialization. You might need to regenerate the generated protobuf code.");
			}
			ctx.CopyStateTo(ctx.state.CodedOutputStream);
			try
			{
				message.WriteTo(ctx.state.CodedOutputStream);
			}
			finally
			{
				ctx.LoadStateFrom(ctx.state.CodedOutputStream);
			}
		}
	}
}
namespace Google.Protobuf.WellKnownTypes
{
	public static class AnyReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static AnyReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Chlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvEg9nb29nbGUucHJvdG9idWYi" + "JgoDQW55EhAKCHR5cGVfdXJsGAEgASgJEg0KBXZhbHVlGAIgASgMQnYKE2Nv" + "bS5nb29nbGUucHJvdG9idWZCCEFueVByb3RvUAFaLGdvb2dsZS5nb2xhbmcu" + "b3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2FueXBiogIDR1BCqgIeR29vZ2xl" + "LlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZwcm90bzM="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(Any), Any.Parser, new string[2] { "TypeUrl", "Value" }, null, null, null, null)
			}));
		}
	}
	public sealed class Any : IMessage<Any>, IMessage, IEquatable<Any>, IDeepCloneable<Any>, IBufferMessage
	{
		private static readonly MessageParser<Any> _parser = new MessageParser<Any>(() => new Any());

		private UnknownFieldSet _unknownFields;

		public const int TypeUrlFieldNumber = 1;

		private string typeUrl_ = "";

		public const int ValueFieldNumber = 2;

		private ByteString value_ = ByteString.Empty;

		private const string DefaultPrefix = "type.googleapis.com";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Any> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => AnyReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string TypeUrl
		{
			get
			{
				return typeUrl_;
			}
			set
			{
				typeUrl_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ByteString Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Any()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Any(Any other)
			: this()
		{
			typeUrl_ = other.typeUrl_;
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Any Clone()
		{
			return new Any(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Any);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Any other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TypeUrl != other.TypeUrl)
			{
				return false;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (TypeUrl.Length != 0)
			{
				num ^= TypeUrl.GetHashCode();
			}
			if (Value.Length != 0)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (TypeUrl.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(TypeUrl);
			}
			if (Value.Length != 0)
			{
				output.WriteRawTag(18);
				output.WriteBytes(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (TypeUrl.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeUrl);
			}
			if (Value.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Any other)
		{
			if (other != null)
			{
				if (other.TypeUrl.Length != 0)
				{
					TypeUrl = other.TypeUrl;
				}
				if (other.Value.Length != 0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					TypeUrl = input.ReadString();
					break;
				case 18u:
					Value = input.ReadBytes();
					break;
				}
			}
		}

		private static string GetTypeUrl(MessageDescriptor descriptor, string prefix)
		{
			if (!prefix.EndsWith("/"))
			{
				return prefix + "/" + descriptor.FullName;
			}
			return prefix + descriptor.FullName;
		}

		public static string GetTypeName(string typeUrl)
		{
			ProtoPreconditions.CheckNotNull(typeUrl, "typeUrl");
			int num = typeUrl.LastIndexOf('/');
			if (num != -1)
			{
				return typeUrl.Substring(num + 1);
			}
			return "";
		}

		public bool Is(MessageDescriptor descriptor)
		{
			ProtoPreconditions.CheckNotNull(descriptor, "descriptor");
			return GetTypeName(TypeUrl) == descriptor.FullName;
		}

		public T Unpack<T>() where T : IMessage, new()
		{
			T val = new T();
			if (GetTypeName(TypeUrl) != val.Descriptor.FullName)
			{
				throw new InvalidProtocolBufferException("Full type name for " + val.Descriptor.Name + " is " + val.Descriptor.FullName + "; Any message's type url is " + TypeUrl);
			}
			val.MergeFrom(Value);
			return val;
		}

		public bool TryUnpack<T>(out T result) where T : IMessage, new()
		{
			T val = new T();
			if (GetTypeName(TypeUrl) != val.Descriptor.FullName)
			{
				result = default(T);
				return false;
			}
			val.MergeFrom(Value);
			result = val;
			return true;
		}

		public static Any Pack(IMessage message)
		{
			return Pack(message, "type.googleapis.com");
		}

		public static Any Pack(IMessage message, string typeUrlPrefix)
		{
			ProtoPreconditions.CheckNotNull(message, "message");
			ProtoPreconditions.CheckNotNull(typeUrlPrefix, "typeUrlPrefix");
			return new Any
			{
				TypeUrl = GetTypeUrl(message.Descriptor, typeUrlPrefix),
				Value = message.ToByteString()
			};
		}
	}
	public static class ApiReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static ApiReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Chlnb29nbGUvcHJvdG9idWYvYXBpLnByb3RvEg9nb29nbGUucHJvdG9idWYa" + "JGdvb2dsZS9wcm90b2J1Zi9zb3VyY2VfY29udGV4dC5wcm90bxoaZ29vZ2xl" + "L3Byb3RvYnVmL3R5cGUucHJvdG8igQIKA0FwaRIMCgRuYW1lGAEgASgJEigK" + "B21ldGhvZHMYAiADKAsyFy5nb29nbGUucHJvdG9idWYuTWV0aG9kEigKB29w" + "dGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9uEg8KB3ZlcnNp" + "b24YBCABKAkSNgoOc291cmNlX2NvbnRleHQYBSABKAsyHi5nb29nbGUucHJv" + "dG9idWYuU291cmNlQ29udGV4dBImCgZtaXhpbnMYBiADKAsyFi5nb29nbGUu" + "cHJvdG9idWYuTWl4aW4SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3Rv" + "YnVmLlN5bnRheCLVAQoGTWV0aG9kEgwKBG5hbWUYASABKAkSGAoQcmVxdWVz" + "dF90eXBlX3VybBgCIAEoCRIZChFyZXF1ZXN0X3N0cmVhbWluZxgDIAEoCBIZ" + "ChFyZXNwb25zZV90eXBlX3VybBgEIAEoCRIaChJyZXNwb25zZV9zdHJlYW1p" + "bmcYBSABKAgSKAoHb3B0aW9ucxgGIAMoCzIXLmdvb2dsZS5wcm90b2J1Zi5P" + "cHRpb24SJwoGc3ludGF4GAcgASgOMhcuZ29vZ2xlLnByb3RvYnVmLlN5bnRh" + "eCIjCgVNaXhpbhIMCgRuYW1lGAEgASgJEgwKBHJvb3QYAiABKAlCdgoTY29t" + "Lmdvb2dsZS5wcm90b2J1ZkIIQXBpUHJvdG9QAVosZ29vZ2xlLmdvbGFuZy5v" + "cmcvcHJvdG9idWYvdHlwZXMva25vd24vYXBpcGKiAgNHUEKqAh5Hb29nbGUu" + "UHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw=="), new FileDescriptor[2]
			{
				SourceContextReflection.Descriptor,
				TypeReflection.Descriptor
			}, new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[3]
			{
				new GeneratedClrTypeInfo(typeof(Api), Api.Parser, new string[7] { "Name", "Methods", "Options", "Version", "SourceContext", "Mixins", "Syntax" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Method), Method.Parser, new string[7] { "Name", "RequestTypeUrl", "RequestStreaming", "ResponseTypeUrl", "ResponseStreaming", "Options", "Syntax" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Mixin), Mixin.Parser, new string[2] { "Name", "Root" }, null, null, null, null)
			}));
		}
	}
	public sealed class Api : IMessage<Api>, IMessage, IEquatable<Api>, IDeepCloneable<Api>, IBufferMessage
	{
		private static readonly MessageParser<Api> _parser = new MessageParser<Api>(() => new Api());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int MethodsFieldNumber = 2;

		private static readonly FieldCodec<Method> _repeated_methods_codec = FieldCodec.ForMessage(18u, Method.Parser);

		private readonly RepeatedField<Method> methods_ = new RepeatedField<Method>();

		public const int OptionsFieldNumber = 3;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(26u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		public const int VersionFieldNumber = 4;

		private string version_ = "";

		public const int SourceContextFieldNumber = 5;

		private SourceContext sourceContext_;

		public const int MixinsFieldNumber = 6;

		private static readonly FieldCodec<Mixin> _repeated_mixins_codec = FieldCodec.ForMessage(50u, Mixin.Parser);

		private readonly RepeatedField<Mixin> mixins_ = new RepeatedField<Mixin>();

		public const int SyntaxFieldNumber = 7;

		private Syntax syntax_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Api> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => ApiReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Method> Methods => methods_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext SourceContext
		{
			get
			{
				return sourceContext_;
			}
			set
			{
				sourceContext_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Mixin> Mixins => mixins_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Syntax Syntax
		{
			get
			{
				return syntax_;
			}
			set
			{
				syntax_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Api()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Api(Api other)
			: this()
		{
			name_ = other.name_;
			methods_ = other.methods_.Clone();
			options_ = other.options_.Clone();
			version_ = other.version_;
			sourceContext_ = ((other.sourceContext_ != null) ? other.sourceContext_.Clone() : null);
			mixins_ = other.mixins_.Clone();
			syntax_ = other.syntax_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Api Clone()
		{
			return new Api(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Api);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Api other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!methods_.Equals(other.methods_))
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			if (Version != other.Version)
			{
				return false;
			}
			if (!object.Equals(SourceContext, other.SourceContext))
			{
				return false;
			}
			if (!mixins_.Equals(other.mixins_))
			{
				return false;
			}
			if (Syntax != other.Syntax)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= methods_.GetHashCode();
			num ^= options_.GetHashCode();
			if (Version.Length != 0)
			{
				num ^= Version.GetHashCode();
			}
			if (sourceContext_ != null)
			{
				num ^= SourceContext.GetHashCode();
			}
			num ^= mixins_.GetHashCode();
			if (Syntax != Syntax.Proto2)
			{
				num ^= Syntax.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			methods_.WriteTo(ref output, _repeated_methods_codec);
			options_.WriteTo(ref output, _repeated_options_codec);
			if (Version.Length != 0)
			{
				output.WriteRawTag(34);
				output.WriteString(Version);
			}
			if (sourceContext_ != null)
			{
				output.WriteRawTag(42);
				output.WriteMessage(SourceContext);
			}
			mixins_.WriteTo(ref output, _repeated_mixins_codec);
			if (Syntax != Syntax.Proto2)
			{
				output.WriteRawTag(56);
				output.WriteEnum((int)Syntax);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += methods_.CalculateSize(_repeated_methods_codec);
			num += options_.CalculateSize(_repeated_options_codec);
			if (Version.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Version);
			}
			if (sourceContext_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(SourceContext);
			}
			num += mixins_.CalculateSize(_repeated_mixins_codec);
			if (Syntax != Syntax.Proto2)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Syntax);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Api other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			methods_.Add(other.methods_);
			options_.Add(other.options_);
			if (other.Version.Length != 0)
			{
				Version = other.Version;
			}
			if (other.sourceContext_ != null)
			{
				if (sourceContext_ == null)
				{
					SourceContext = new SourceContext();
				}
				SourceContext.MergeFrom(other.SourceContext);
			}
			mixins_.Add(other.mixins_);
			if (other.Syntax != Syntax.Proto2)
			{
				Syntax = other.Syntax;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					methods_.AddEntriesFrom(ref input, _repeated_methods_codec);
					break;
				case 26u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				case 34u:
					Version = input.ReadString();
					break;
				case 42u:
					if (sourceContext_ == null)
					{
						SourceContext = new SourceContext();
					}
					input.ReadMessage(SourceContext);
					break;
				case 50u:
					mixins_.AddEntriesFrom(ref input, _repeated_mixins_codec);
					break;
				case 56u:
					Syntax = (Syntax)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class Method : IMessage<Method>, IMessage, IEquatable<Method>, IDeepCloneable<Method>, IBufferMessage
	{
		private static readonly MessageParser<Method> _parser = new MessageParser<Method>(() => new Method());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int RequestTypeUrlFieldNumber = 2;

		private string requestTypeUrl_ = "";

		public const int RequestStreamingFieldNumber = 3;

		private bool requestStreaming_;

		public const int ResponseTypeUrlFieldNumber = 4;

		private string responseTypeUrl_ = "";

		public const int ResponseStreamingFieldNumber = 5;

		private bool responseStreaming_;

		public const int OptionsFieldNumber = 6;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(50u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		public const int SyntaxFieldNumber = 7;

		private Syntax syntax_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Method> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => ApiReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string RequestTypeUrl
		{
			get
			{
				return requestTypeUrl_;
			}
			set
			{
				requestTypeUrl_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool RequestStreaming
		{
			get
			{
				return requestStreaming_;
			}
			set
			{
				requestStreaming_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string ResponseTypeUrl
		{
			get
			{
				return responseTypeUrl_;
			}
			set
			{
				responseTypeUrl_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool ResponseStreaming
		{
			get
			{
				return responseStreaming_;
			}
			set
			{
				responseStreaming_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Syntax Syntax
		{
			get
			{
				return syntax_;
			}
			set
			{
				syntax_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Method()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Method(Method other)
			: this()
		{
			name_ = other.name_;
			requestTypeUrl_ = other.requestTypeUrl_;
			requestStreaming_ = other.requestStreaming_;
			responseTypeUrl_ = other.responseTypeUrl_;
			responseStreaming_ = other.responseStreaming_;
			options_ = other.options_.Clone();
			syntax_ = other.syntax_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Method Clone()
		{
			return new Method(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Method);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Method other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (RequestTypeUrl != other.RequestTypeUrl)
			{
				return false;
			}
			if (RequestStreaming != other.RequestStreaming)
			{
				return false;
			}
			if (ResponseTypeUrl != other.ResponseTypeUrl)
			{
				return false;
			}
			if (ResponseStreaming != other.ResponseStreaming)
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			if (Syntax != other.Syntax)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (RequestTypeUrl.Length != 0)
			{
				num ^= RequestTypeUrl.GetHashCode();
			}
			if (RequestStreaming)
			{
				num ^= RequestStreaming.GetHashCode();
			}
			if (ResponseTypeUrl.Length != 0)
			{
				num ^= ResponseTypeUrl.GetHashCode();
			}
			if (ResponseStreaming)
			{
				num ^= ResponseStreaming.GetHashCode();
			}
			num ^= options_.GetHashCode();
			if (Syntax != Syntax.Proto2)
			{
				num ^= Syntax.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (RequestTypeUrl.Length != 0)
			{
				output.WriteRawTag(18);
				output.WriteString(RequestTypeUrl);
			}
			if (RequestStreaming)
			{
				output.WriteRawTag(24);
				output.WriteBool(RequestStreaming);
			}
			if (ResponseTypeUrl.Length != 0)
			{
				output.WriteRawTag(34);
				output.WriteString(ResponseTypeUrl);
			}
			if (ResponseStreaming)
			{
				output.WriteRawTag(40);
				output.WriteBool(ResponseStreaming);
			}
			options_.WriteTo(ref output, _repeated_options_codec);
			if (Syntax != Syntax.Proto2)
			{
				output.WriteRawTag(56);
				output.WriteEnum((int)Syntax);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (RequestTypeUrl.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(RequestTypeUrl);
			}
			if (RequestStreaming)
			{
				num += 2;
			}
			if (ResponseTypeUrl.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ResponseTypeUrl);
			}
			if (ResponseStreaming)
			{
				num += 2;
			}
			num += options_.CalculateSize(_repeated_options_codec);
			if (Syntax != Syntax.Proto2)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Syntax);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Method other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.RequestTypeUrl.Length != 0)
				{
					RequestTypeUrl = other.RequestTypeUrl;
				}
				if (other.RequestStreaming)
				{
					RequestStreaming = other.RequestStreaming;
				}
				if (other.ResponseTypeUrl.Length != 0)
				{
					ResponseTypeUrl = other.ResponseTypeUrl;
				}
				if (other.ResponseStreaming)
				{
					ResponseStreaming = other.ResponseStreaming;
				}
				options_.Add(other.options_);
				if (other.Syntax != Syntax.Proto2)
				{
					Syntax = other.Syntax;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					RequestTypeUrl = input.ReadString();
					break;
				case 24u:
					RequestStreaming = input.ReadBool();
					break;
				case 34u:
					ResponseTypeUrl = input.ReadString();
					break;
				case 40u:
					ResponseStreaming = input.ReadBool();
					break;
				case 50u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				case 56u:
					Syntax = (Syntax)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class Mixin : IMessage<Mixin>, IMessage, IEquatable<Mixin>, IDeepCloneable<Mixin>, IBufferMessage
	{
		private static readonly MessageParser<Mixin> _parser = new MessageParser<Mixin>(() => new Mixin());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int RootFieldNumber = 2;

		private string root_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Mixin> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => ApiReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Root
		{
			get
			{
				return root_;
			}
			set
			{
				root_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Mixin()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Mixin(Mixin other)
			: this()
		{
			name_ = other.name_;
			root_ = other.root_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Mixin Clone()
		{
			return new Mixin(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Mixin);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Mixin other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Root != other.Root)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Root.Length != 0)
			{
				num ^= Root.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (Root.Length != 0)
			{
				output.WriteRawTag(18);
				output.WriteString(Root);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Root.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Root);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Mixin other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.Root.Length != 0)
				{
					Root = other.Root;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					Root = input.ReadString();
					break;
				}
			}
		}
	}
	public static class DurationReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static DurationReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ch5nb29nbGUvcHJvdG9idWYvZHVyYXRpb24ucHJvdG8SD2dvb2dsZS5wcm90" + "b2J1ZiIqCghEdXJhdGlvbhIPCgdzZWNvbmRzGAEgASgDEg0KBW5hbm9zGAIg" + "ASgFQoMBChNjb20uZ29vZ2xlLnByb3RvYnVmQg1EdXJhdGlvblByb3RvUAFa" + "MWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2R1cmF0" + "aW9ucGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlw" + "ZXNiBnByb3RvMw=="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(Duration), Duration.Parser, new string[2] { "Seconds", "Nanos" }, null, null, null, null)
			}));
		}
	}
	public sealed class Duration : IMessage<Duration>, IMessage, IEquatable<Duration>, IDeepCloneable<Duration>, IBufferMessage, ICustomDiagnosticMessage
	{
		private static readonly MessageParser<Duration> _parser = new MessageParser<Duration>(() => new Duration());

		private UnknownFieldSet _unknownFields;

		public const int SecondsFieldNumber = 1;

		private long seconds_;

		public const int NanosFieldNumber = 2;

		private int nanos_;

		public const int NanosecondsPerSecond = 1000000000;

		public const int NanosecondsPerTick = 100;

		public const long MaxSeconds = 315576000000L;

		public const long MinSeconds = -315576000000L;

		internal const int MaxNanoseconds = 999999999;

		internal const int MinNanoseconds = -999999999;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Duration> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DurationReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public long Seconds
		{
			get
			{
				return seconds_;
			}
			set
			{
				seconds_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Nanos
		{
			get
			{
				return nanos_;
			}
			set
			{
				nanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Duration()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Duration(Duration other)
			: this()
		{
			seconds_ = other.seconds_;
			nanos_ = other.nanos_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Duration Clone()
		{
			return new Duration(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Duration);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Duration other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Seconds != other.Seconds)
			{
				return false;
			}
			if (Nanos != other.Nanos)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Seconds != 0L)
			{
				num ^= Seconds.GetHashCode();
			}
			if (Nanos != 0)
			{
				num ^= Nanos.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Seconds != 0L)
			{
				output.WriteRawTag(8);
				output.WriteInt64(Seconds);
			}
			if (Nanos != 0)
			{
				output.WriteRawTag(16);
				output.WriteInt32(Nanos);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Seconds != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Seconds);
			}
			if (Nanos != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Nanos);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Duration other)
		{
			if (other != null)
			{
				if (other.Seconds != 0L)
				{
					Seconds = other.Seconds;
				}
				if (other.Nanos != 0)
				{
					Nanos = other.Nanos;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					Seconds = input.ReadInt64();
					break;
				case 16u:
					Nanos = input.ReadInt32();
					break;
				}
			}
		}

		internal static bool IsNormalized(long seconds, int nanoseconds)
		{
			if (seconds < -315576000000L || seconds > 315576000000L || nanoseconds < -999999999 || nanoseconds > 999999999)
			{
				return false;
			}
			return Math.Sign(seconds) * Math.Sign(nanoseconds) != -1;
		}

		public TimeSpan ToTimeSpan()
		{
			if (!IsNormalized(Seconds, Nanos))
			{
				throw new InvalidOperationException("Duration was not a valid normalized duration");
			}
			checked
			{
				return TimeSpan.FromTicks(Seconds * 10000000 + unchecked(Nanos / 100));
			}
		}

		public static Duration FromTimeSpan(TimeSpan timeSpan)
		{
			long ticks = timeSpan.Ticks;
			long seconds = ticks / 10000000;
			checked
			{
				int nanos = (int)unchecked(ticks % 10000000) * 100;
				return new Duration
				{
					Seconds = seconds,
					Nanos = nanos
				};
			}
		}

		public static Duration operator -(Duration value)
		{
			ProtoPreconditions.CheckNotNull(value, "value");
			return checked(Normalize(-value.Seconds, -value.Nanos));
		}

		public static Duration operator +(Duration lhs, Duration rhs)
		{
			ProtoPreconditions.CheckNotNull(lhs, "lhs");
			ProtoPreconditions.CheckNotNull(rhs, "rhs");
			return checked(Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos));
		}

		public static Duration operator -(Duration lhs, Duration rhs)
		{
			ProtoPreconditions.CheckNotNull(lhs, "lhs");
			ProtoPreconditions.CheckNotNull(rhs, "rhs");
			return checked(Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos));
		}

		internal static Duration Normalize(long seconds, int nanoseconds)
		{
			int num = nanoseconds / 1000000000;
			seconds += num;
			nanoseconds -= num * 1000000000;
			if (seconds < 0 && nanoseconds > 0)
			{
				seconds++;
				nanoseconds -= 1000000000;
			}
			else if (seconds > 0 && nanoseconds < 0)
			{
				seconds--;
				nanoseconds += 1000000000;
			}
			return new Duration
			{
				Seconds = seconds,
				Nanos = nanoseconds
			};
		}

		internal static string ToJson(long seconds, int nanoseconds, bool diagnosticOnly)
		{
			if (IsNormalized(seconds, nanoseconds))
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('"');
				if (seconds == 0L && nanoseconds < 0)
				{
					stringBuilder.Append('-');
				}
				stringBuilder.Append(seconds.ToString("d", CultureInfo.InvariantCulture));
				AppendNanoseconds(stringBuilder, Math.Abs(nanoseconds));
				stringBuilder.Append("s\"");
				return stringBuilder.ToString();
			}
			if (diagnosticOnly)
			{
				return string.Format(CultureInfo.InvariantCulture, "{{ \"@warning\": \"Invalid Duration\", \"seconds\": \"{0}\", \"nanos\": {1} }}", seconds, nanoseconds);
			}
			throw new InvalidOperationException("Non-normalized duration value");
		}

		public string ToDiagnosticString()
		{
			return ToJson(Seconds, Nanos, diagnosticOnly: true);
		}

		internal static void AppendNanoseconds(StringBuilder builder, int nanos)
		{
			if (nanos != 0)
			{
				builder.Append('.');
				if (nanos % 1000000 == 0)
				{
					builder.Append((nanos / 1000000).ToString("d3", CultureInfo.InvariantCulture));
				}
				else if (nanos % 1000 == 0)
				{
					builder.Append((nanos / 1000).ToString("d6", CultureInfo.InvariantCulture));
				}
				else
				{
					builder.Append(nanos.ToString("d9", CultureInfo.InvariantCulture));
				}
			}
		}
	}
	public static class EmptyReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static EmptyReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Chtnb29nbGUvcHJvdG9idWYvZW1wdHkucHJvdG8SD2dvb2dsZS5wcm90b2J1" + "ZiIHCgVFbXB0eUJ9ChNjb20uZ29vZ2xlLnByb3RvYnVmQgpFbXB0eVByb3Rv" + "UAFaLmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL2Vt" + "cHR5cGL4AQGiAgNHUEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlw" + "ZXNiBnByb3RvMw=="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(Empty), Empty.Parser, null, null, null, null, null)
			}));
		}
	}
	public sealed class Empty : IMessage<Empty>, IMessage, IEquatable<Empty>, IDeepCloneable<Empty>, IBufferMessage
	{
		private static readonly MessageParser<Empty> _parser = new MessageParser<Empty>(() => new Empty());

		private UnknownFieldSet _unknownFields;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Empty> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => EmptyReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Empty()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Empty(Empty other)
			: this()
		{
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Empty Clone()
		{
			return new Empty(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Empty);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Empty other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Empty other)
		{
			if (other != null)
			{
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			while (input.ReadTag() != 0)
			{
				_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
			}
		}
	}
	public static class FieldMaskReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static FieldMaskReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxIPZ29vZ2xlLnBy" + "b3RvYnVmIhoKCUZpZWxkTWFzaxINCgVwYXRocxgBIAMoCUKFAQoTY29tLmdv" + "b2dsZS5wcm90b2J1ZkIORmllbGRNYXNrUHJvdG9QAVoyZ29vZ2xlLmdvbGFu" + "Zy5vcmcvcHJvdG9idWYvdHlwZXMva25vd24vZmllbGRtYXNrcGL4AQGiAgNH" + "UEKqAh5Hb29nbGUuUHJvdG9idWYuV2VsbEtub3duVHlwZXNiBnByb3RvMw=="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(FieldMask), FieldMask.Parser, new string[1] { "Paths" }, null, null, null, null)
			}));
		}
	}
	public sealed class FieldMask : IMessage<FieldMask>, IMessage, IEquatable<FieldMask>, IDeepCloneable<FieldMask>, IBufferMessage, ICustomDiagnosticMessage
	{
		public sealed class MergeOptions
		{
			public bool ReplaceMessageFields { get; set; }

			public bool ReplaceRepeatedFields { get; set; }

			public bool ReplacePrimitiveFields { get; set; }
		}

		private static readonly MessageParser<FieldMask> _parser = new MessageParser<FieldMask>(() => new FieldMask());

		private UnknownFieldSet _unknownFields;

		public const int PathsFieldNumber = 1;

		private static readonly FieldCodec<string> _repeated_paths_codec = FieldCodec.ForString(10u);

		private readonly RepeatedField<string> paths_ = new RepeatedField<string>();

		private const char FIELD_PATH_SEPARATOR = ',';

		private const char FIELD_SEPARATOR_REGEX = '.';

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FieldMask> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => FieldMaskReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<string> Paths => paths_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldMask()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldMask(FieldMask other)
			: this()
		{
			paths_ = other.paths_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldMask Clone()
		{
			return new FieldMask(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FieldMask);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FieldMask other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!paths_.Equals(other.paths_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= paths_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			paths_.WriteTo(ref output, _repeated_paths_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += paths_.CalculateSize(_repeated_paths_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FieldMask other)
		{
			if (other != null)
			{
				paths_.Add(other.paths_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					paths_.AddEntriesFrom(ref input, _repeated_paths_codec);
				}
			}
		}

		internal static string ToJson(IList<string> paths, bool diagnosticOnly)
		{
			string text = paths.FirstOrDefault((string p) => !IsPathValid(p));
			if (text == null)
			{
				StringWriter stringWriter = new StringWriter();
				JsonFormatter.WriteString(stringWriter, string.Join(",", paths.Select(JsonFormatter.ToJsonName)));
				return stringWriter.ToString();
			}
			if (diagnosticOnly)
			{
				StringWriter stringWriter2 = new StringWriter();
				stringWriter2.Write("{ \"@warning\": \"Invalid FieldMask\", \"paths\": ");
				JsonFormatter.Default.WriteList(stringWriter2, (IList)paths);
				stringWriter2.Write(" }");
				return stringWriter2.ToString();
			}
			throw new InvalidOperationException("Invalid field mask to be converted to JSON: " + text);
		}

		public string ToDiagnosticString()
		{
			return ToJson(Paths, diagnosticOnly: true);
		}

		public static FieldMask FromString(string value)
		{
			return FromStringEnumerable<Empty>(new List<string>(value.Split(new char[1] { ',' })));
		}

		public static FieldMask FromString<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(string value) where T : IMessage
		{
			return FromStringEnumerable<T>(new List<string>(value.Split(new char[1] { ',' })));
		}

		public static FieldMask FromStringEnumerable<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(IEnumerable<string> paths) where T : IMessage
		{
			FieldMask fieldMask = new FieldMask();
			foreach (string path in paths)
			{
				if (path.Length != 0)
				{
					if (typeof(T) != typeof(Empty) && !IsValid<T>(path))
					{
						throw new InvalidProtocolBufferException(path + " is not a valid path for " + typeof(T));
					}
					fieldMask.Paths.Add(path);
				}
			}
			return fieldMask;
		}

		public static FieldMask FromFieldNumbers<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(params int[] fieldNumbers) where T : IMessage
		{
			return FromFieldNumbers<T>((IEnumerable<int>)fieldNumbers);
		}

		public static FieldMask FromFieldNumbers<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(IEnumerable<int> fieldNumbers) where T : IMessage
		{
			MessageDescriptor descriptor = Activator.CreateInstance<T>().Descriptor;
			FieldMask fieldMask = new FieldMask();
			foreach (int fieldNumber in fieldNumbers)
			{
				FieldDescriptor fieldDescriptor = descriptor.FindFieldByNumber(fieldNumber);
				if (fieldDescriptor == null)
				{
					throw new ArgumentNullException($"{fieldNumber} is not a valid field number for {descriptor.Name}");
				}
				fieldMask.Paths.Add(fieldDescriptor.Name);
			}
			return fieldMask;
		}

		private static bool IsPathValid(string input)
		{
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (c >= 'A' && c <= 'Z')
				{
					return false;
				}
				if (c == '_' && i < input.Length - 1)
				{
					char c2 = input[i + 1];
					if (c2 < 'a' || c2 > 'z')
					{
						return false;
					}
				}
			}
			return true;
		}

		public static bool IsValid<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(FieldMask fieldMask) where T : IMessage
		{
			return IsValid(Activator.CreateInstance<T>().Descriptor, fieldMask);
		}

		public static bool IsValid(MessageDescriptor descriptor, FieldMask fieldMask)
		{
			foreach (string path in fieldMask.Paths)
			{
				if (!IsValid(descriptor, path))
				{
					return false;
				}
			}
			return true;
		}

		public static bool IsValid<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] T>(string path) where T : IMessage
		{
			return IsValid(Activator.CreateInstance<T>().Descriptor, path);
		}

		public static bool IsValid(MessageDescriptor descriptor, string path)
		{
			string[] array = path.Split(new char[1] { '.' });
			if (array.Length == 0)
			{
				return false;
			}
			string[] array2 = array;
			foreach (string name in array2)
			{
				FieldDescriptor fieldDescriptor = descriptor?.FindFieldByName(name);
				if (fieldDescriptor == null)
				{
					return false;
				}
				descriptor = ((fieldDescriptor.IsRepeated || fieldDescriptor.FieldType != FieldType.Message) ? null : fieldDescriptor.MessageType);
			}
			return true;
		}

		public FieldMask Normalize()
		{
			return new FieldMaskTree(this).ToFieldMask();
		}

		public FieldMask Union(params FieldMask[] otherMasks)
		{
			FieldMaskTree fieldMaskTree = new FieldMaskTree(this);
			foreach (FieldMask mask in otherMasks)
			{
				fieldMaskTree.MergeFromFieldMask(mask);
			}
			return fieldMaskTree.ToFieldMask();
		}

		public FieldMask Intersection(FieldMask additionalMask)
		{
			FieldMaskTree fieldMaskTree = new FieldMaskTree(this);
			FieldMaskTree fieldMaskTree2 = new FieldMaskTree();
			foreach (string path in additionalMask.Paths)
			{
				fieldMaskTree.IntersectFieldPath(path, fieldMaskTree2);
			}
			return fieldMaskTree2.ToFieldMask();
		}

		public void Merge(IMessage source, IMessage destination, MergeOptions options)
		{
			new FieldMaskTree(this).Merge(source, destination, options);
		}

		public void Merge(IMessage source, IMessage destination)
		{
			Merge(source, destination, new MergeOptions());
		}
	}
	public static class SourceContextReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static SourceContextReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiRnb29nbGUvcHJvdG9idWYvc291cmNlX2NvbnRleHQucHJvdG8SD2dvb2ds" + "ZS5wcm90b2J1ZiIiCg1Tb3VyY2VDb250ZXh0EhEKCWZpbGVfbmFtZRgBIAEo" + "CUKKAQoTY29tLmdvb2dsZS5wcm90b2J1ZkISU291cmNlQ29udGV4dFByb3Rv" + "UAFaNmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3Nv" + "dXJjZWNvbnRleHRwYqICA0dQQqoCHkdvb2dsZS5Qcm90b2J1Zi5XZWxsS25v" + "d25UeXBlc2IGcHJvdG8z"), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(SourceContext), SourceContext.Parser, new string[1] { "FileName" }, null, null, null, null)
			}));
		}
	}
	public sealed class SourceContext : IMessage<SourceContext>, IMessage, IEquatable<SourceContext>, IDeepCloneable<SourceContext>, IBufferMessage
	{
		private static readonly MessageParser<SourceContext> _parser = new MessageParser<SourceContext>(() => new SourceContext());

		private UnknownFieldSet _unknownFields;

		public const int FileNameFieldNumber = 1;

		private string fileName_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<SourceContext> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => SourceContextReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string FileName
		{
			get
			{
				return fileName_;
			}
			set
			{
				fileName_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext(SourceContext other)
			: this()
		{
			fileName_ = other.fileName_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext Clone()
		{
			return new SourceContext(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as SourceContext);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(SourceContext other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (FileName != other.FileName)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (FileName.Length != 0)
			{
				num ^= FileName.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (FileName.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(FileName);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (FileName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FileName);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(SourceContext other)
		{
			if (other != null)
			{
				if (other.FileName.Length != 0)
				{
					FileName = other.FileName;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					FileName = input.ReadString();
				}
			}
		}
	}
	public static class StructReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static StructReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Chxnb29nbGUvcHJvdG9idWYvc3RydWN0LnByb3RvEg9nb29nbGUucHJvdG9i" + "dWYihAEKBlN0cnVjdBIzCgZmaWVsZHMYASADKAsyIy5nb29nbGUucHJvdG9i" + "dWYuU3RydWN0LkZpZWxkc0VudHJ5GkUKC0ZpZWxkc0VudHJ5EgsKA2tleRgB" + "IAEoCRIlCgV2YWx1ZRgCIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZToC" + "OAEi6gEKBVZhbHVlEjAKCm51bGxfdmFsdWUYASABKA4yGi5nb29nbGUucHJv" + "dG9idWYuTnVsbFZhbHVlSAASFgoMbnVtYmVyX3ZhbHVlGAIgASgBSAASFgoM" + "c3RyaW5nX3ZhbHVlGAMgASgJSAASFAoKYm9vbF92YWx1ZRgEIAEoCEgAEi8K" + "DHN0cnVjdF92YWx1ZRgFIAEoCzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RI" + "ABIwCgpsaXN0X3ZhbHVlGAYgASgLMhouZ29vZ2xlLnByb3RvYnVmLkxpc3RW" + "YWx1ZUgAQgYKBGtpbmQiMwoJTGlzdFZhbHVlEiYKBnZhbHVlcxgBIAMoCzIW" + "Lmdvb2dsZS5wcm90b2J1Zi5WYWx1ZSobCglOdWxsVmFsdWUSDgoKTlVMTF9W" + "QUxVRRAAQn8KE2NvbS5nb29nbGUucHJvdG9idWZCC1N0cnVjdFByb3RvUAFa" + "L2dvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3N0cnVj" + "dHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVz" + "YgZwcm90bzM="), new FileDescriptor[0], new GeneratedClrTypeInfo(new System.Type[1] { typeof(NullValue) }, null, new GeneratedClrTypeInfo[3]
			{
				new GeneratedClrTypeInfo(typeof(Struct), Struct.Parser, new string[1] { "Fields" }, null, null, null, new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(Value), Value.Parser, new string[6] { "NullValue", "NumberValue", "StringValue", "BoolValue", "StructValue", "ListValue" }, new string[1] { "Kind" }, null, null, null),
				new GeneratedClrTypeInfo(typeof(ListValue), ListValue.Parser, new string[1] { "Values" }, null, null, null, null)
			}));
		}
	}
	public enum NullValue
	{
		[OriginalName("NULL_VALUE")]
		NullValue
	}
	public sealed class Struct : IMessage<Struct>, IMessage, IEquatable<Struct>, IDeepCloneable<Struct>, IBufferMessage
	{
		private static readonly MessageParser<Struct> _parser = new MessageParser<Struct>(() => new Struct());

		private UnknownFieldSet _unknownFields;

		public const int FieldsFieldNumber = 1;

		private static readonly MapField<string, Value>.Codec _map_fields_codec = new MapField<string, Value>.Codec(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage(18u, Value.Parser), 10u);

		private readonly MapField<string, Value> fields_ = new MapField<string, Value>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Struct> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MapField<string, Value> Fields => fields_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Struct()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Struct(Struct other)
			: this()
		{
			fields_ = other.fields_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Struct Clone()
		{
			return new Struct(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Struct);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Struct other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!Fields.Equals(other.Fields))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= Fields.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			fields_.WriteTo(ref output, _map_fields_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += fields_.CalculateSize(_map_fields_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Struct other)
		{
			if (other != null)
			{
				fields_.Add(other.fields_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					fields_.AddEntriesFrom(ref input, _map_fields_codec);
				}
			}
		}
	}
	public sealed class Value : IMessage<Value>, IMessage, IEquatable<Value>, IDeepCloneable<Value>, IBufferMessage
	{
		public enum KindOneofCase
		{
			None,
			NullValue,
			NumberValue,
			StringValue,
			BoolValue,
			StructValue,
			ListValue
		}

		private static readonly MessageParser<Value> _parser = new MessageParser<Value>(() => new Value());

		private UnknownFieldSet _unknownFields;

		public const int NullValueFieldNumber = 1;

		public const int NumberValueFieldNumber = 2;

		public const int StringValueFieldNumber = 3;

		public const int BoolValueFieldNumber = 4;

		public const int StructValueFieldNumber = 5;

		public const int ListValueFieldNumber = 6;

		private object kind_;

		private KindOneofCase kindCase_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Value> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public NullValue NullValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.NullValue)
				{
					return NullValue.NullValue;
				}
				return (NullValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.NullValue;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public double NumberValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.NumberValue)
				{
					return 0.0;
				}
				return (double)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.NumberValue;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string StringValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.StringValue)
				{
					return "";
				}
				return (string)kind_;
			}
			set
			{
				kind_ = ProtoPreconditions.CheckNotNull(value, "value");
				kindCase_ = KindOneofCase.StringValue;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool BoolValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.BoolValue)
				{
					return false;
				}
				return (bool)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.BoolValue;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Struct StructValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.StructValue)
				{
					return null;
				}
				return (Struct)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.StructValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ListValue ListValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.ListValue)
				{
					return null;
				}
				return (ListValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.ListValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public KindOneofCase KindCase => kindCase_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Value()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Value(Value other)
			: this()
		{
			switch (other.KindCase)
			{
			case KindOneofCase.NullValue:
				NullValue = other.NullValue;
				break;
			case KindOneofCase.NumberValue:
				NumberValue = other.NumberValue;
				break;
			case KindOneofCase.StringValue:
				StringValue = other.StringValue;
				break;
			case KindOneofCase.BoolValue:
				BoolValue = other.BoolValue;
				break;
			case KindOneofCase.StructValue:
				StructValue = other.StructValue.Clone();
				break;
			case KindOneofCase.ListValue:
				ListValue = other.ListValue.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Value Clone()
		{
			return new Value(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearKind()
		{
			kindCase_ = KindOneofCase.None;
			kind_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Value);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Value other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (NullValue != other.NullValue)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(NumberValue, other.NumberValue))
			{
				return false;
			}
			if (StringValue != other.StringValue)
			{
				return false;
			}
			if (BoolValue != other.BoolValue)
			{
				return false;
			}
			if (!object.Equals(StructValue, other.StructValue))
			{
				return false;
			}
			if (!object.Equals(ListValue, other.ListValue))
			{
				return false;
			}
			if (KindCase != other.KindCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (kindCase_ == KindOneofCase.NullValue)
			{
				num ^= NullValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.NumberValue)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(NumberValue);
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				num ^= StringValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				num ^= BoolValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.StructValue)
			{
				num ^= StructValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				num ^= ListValue.GetHashCode();
			}
			num ^= (int)kindCase_;
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (kindCase_ == KindOneofCase.NullValue)
			{
				output.WriteRawTag(8);
				output.WriteEnum((int)NullValue);
			}
			if (kindCase_ == KindOneofCase.NumberValue)
			{
				output.WriteRawTag(17);
				output.WriteDouble(NumberValue);
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				output.WriteRawTag(26);
				output.WriteString(StringValue);
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				output.WriteRawTag(32);
				output.WriteBool(BoolValue);
			}
			if (kindCase_ == KindOneofCase.StructValue)
			{
				output.WriteRawTag(42);
				output.WriteMessage(StructValue);
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				output.WriteRawTag(50);
				output.WriteMessage(ListValue);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (kindCase_ == KindOneofCase.NullValue)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)NullValue);
			}
			if (kindCase_ == KindOneofCase.NumberValue)
			{
				num += 9;
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(StringValue);
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				num += 2;
			}
			if (kindCase_ == KindOneofCase.StructValue)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(StructValue);
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(ListValue);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Value other)
		{
			if (other == null)
			{
				return;
			}
			switch (other.KindCase)
			{
			case KindOneofCase.NullValue:
				NullValue = other.NullValue;
				break;
			case KindOneofCase.NumberValue:
				NumberValue = other.NumberValue;
				break;
			case KindOneofCase.StringValue:
				StringValue = other.StringValue;
				break;
			case KindOneofCase.BoolValue:
				BoolValue = other.BoolValue;
				break;
			case KindOneofCase.StructValue:
				if (StructValue == null)
				{
					StructValue = new Struct();
				}
				StructValue.MergeFrom(other.StructValue);
				break;
			case KindOneofCase.ListValue:
				if (ListValue == null)
				{
					ListValue = new ListValue();
				}
				ListValue.MergeFrom(other.ListValue);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					kind_ = input.ReadEnum();
					kindCase_ = KindOneofCase.NullValue;
					break;
				case 17u:
					NumberValue = input.ReadDouble();
					break;
				case 26u:
					StringValue = input.ReadString();
					break;
				case 32u:
					BoolValue = input.ReadBool();
					break;
				case 42u:
				{
					Struct obj = new Struct();
					if (kindCase_ == KindOneofCase.StructValue)
					{
						obj.MergeFrom(StructValue);
					}
					input.ReadMessage(obj);
					StructValue = obj;
					break;
				}
				case 50u:
				{
					ListValue listValue = new ListValue();
					if (kindCase_ == KindOneofCase.ListValue)
					{
						listValue.MergeFrom(ListValue);
					}
					input.ReadMessage(listValue);
					ListValue = listValue;
					break;
				}
				}
			}
		}

		public static Value ForString(string value)
		{
			ProtoPreconditions.CheckNotNull(value, "value");
			return new Value
			{
				StringValue = value
			};
		}

		public static Value ForNumber(double value)
		{
			return new Value
			{
				NumberValue = value
			};
		}

		public static Value ForBool(bool value)
		{
			return new Value
			{
				BoolValue = value
			};
		}

		public static Value ForNull()
		{
			return new Value
			{
				NullValue = NullValue.NullValue
			};
		}

		public static Value ForList(params Value[] values)
		{
			ProtoPreconditions.CheckNotNull(values, "values");
			return new Value
			{
				ListValue = new ListValue
				{
					Values = { (IEnumerable<Value>)values }
				}
			};
		}

		public static Value ForStruct(Struct value)
		{
			ProtoPreconditions.CheckNotNull(value, "value");
			return new Value
			{
				StructValue = value
			};
		}
	}
	public sealed class ListValue : IMessage<ListValue>, IMessage, IEquatable<ListValue>, IDeepCloneable<ListValue>, IBufferMessage
	{
		private static readonly MessageParser<ListValue> _parser = new MessageParser<ListValue>(() => new ListValue());

		private UnknownFieldSet _unknownFields;

		public const int ValuesFieldNumber = 1;

		private static readonly FieldCodec<Value> _repeated_values_codec = FieldCodec.ForMessage(10u, Value.Parser);

		private readonly RepeatedField<Value> values_ = new RepeatedField<Value>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ListValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Value> Values => values_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ListValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ListValue(ListValue other)
			: this()
		{
			values_ = other.values_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ListValue Clone()
		{
			return new ListValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ListValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ListValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!values_.Equals(other.values_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= values_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			values_.WriteTo(ref output, _repeated_values_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += values_.CalculateSize(_repeated_values_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ListValue other)
		{
			if (other != null)
			{
				values_.Add(other.values_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					values_.AddEntriesFrom(ref input, _repeated_values_codec);
				}
			}
		}
	}
	public static class TimeExtensions
	{
		public static Timestamp ToTimestamp(this DateTime dateTime)
		{
			return Timestamp.FromDateTime(dateTime);
		}

		public static Timestamp ToTimestamp(this DateTimeOffset dateTimeOffset)
		{
			return Timestamp.FromDateTimeOffset(dateTimeOffset);
		}

		public static Duration ToDuration(this TimeSpan timeSpan)
		{
			return Duration.FromTimeSpan(timeSpan);
		}
	}
	public static class TimestampReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TimestampReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ch9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnByb3RvEg9nb29nbGUucHJv" + "dG9idWYiKwoJVGltZXN0YW1wEg8KB3NlY29uZHMYASABKAMSDQoFbmFub3MY" + "AiABKAVChQEKE2NvbS5nb29nbGUucHJvdG9idWZCDlRpbWVzdGFtcFByb3Rv" + "UAFaMmdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2tub3duL3Rp" + "bWVzdGFtcHBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93" + "blR5cGVzYgZwcm90bzM="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(Timestamp), Timestamp.Parser, new string[2] { "Seconds", "Nanos" }, null, null, null, null)
			}));
		}
	}
	public sealed class Timestamp : IMessage<Timestamp>, IMessage, IEquatable<Timestamp>, IDeepCloneable<Timestamp>, IBufferMessage, ICustomDiagnosticMessage, IComparable<Timestamp>
	{
		private static readonly MessageParser<Timestamp> _parser = new MessageParser<Timestamp>(() => new Timestamp());

		private UnknownFieldSet _unknownFields;

		public const int SecondsFieldNumber = 1;

		private long seconds_;

		public const int NanosFieldNumber = 2;

		private int nanos_;

		private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		private const long BclSecondsAtUnixEpoch = 62135596800L;

		internal const long UnixSecondsAtBclMaxValue = 253402300799L;

		internal const long UnixSecondsAtBclMinValue = -62135596800L;

		internal const int MaxNanos = 999999999;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Timestamp> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TimestampReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public long Seconds
		{
			get
			{
				return seconds_;
			}
			set
			{
				seconds_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Nanos
		{
			get
			{
				return nanos_;
			}
			set
			{
				nanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Timestamp()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Timestamp(Timestamp other)
			: this()
		{
			seconds_ = other.seconds_;
			nanos_ = other.nanos_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Timestamp Clone()
		{
			return new Timestamp(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Timestamp);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Timestamp other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)other == this)
			{
				return true;
			}
			if (Seconds != other.Seconds)
			{
				return false;
			}
			if (Nanos != other.Nanos)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Seconds != 0L)
			{
				num ^= Seconds.GetHashCode();
			}
			if (Nanos != 0)
			{
				num ^= Nanos.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Seconds != 0L)
			{
				output.WriteRawTag(8);
				output.WriteInt64(Seconds);
			}
			if (Nanos != 0)
			{
				output.WriteRawTag(16);
				output.WriteInt32(Nanos);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Seconds != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Seconds);
			}
			if (Nanos != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Nanos);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Timestamp other)
		{
			if (!(other == null))
			{
				if (other.Seconds != 0L)
				{
					Seconds = other.Seconds;
				}
				if (other.Nanos != 0)
				{
					Nanos = other.Nanos;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					Seconds = input.ReadInt64();
					break;
				case 16u:
					Nanos = input.ReadInt32();
					break;
				}
			}
		}

		private static bool IsNormalized(long seconds, int nanoseconds)
		{
			if (nanoseconds >= 0 && nanoseconds <= 999999999 && seconds >= -62135596800L)
			{
				return seconds <= 253402300799L;
			}
			return false;
		}

		public static Duration operator -(Timestamp lhs, Timestamp rhs)
		{
			ProtoPreconditions.CheckNotNull(lhs, "lhs");
			ProtoPreconditions.CheckNotNull(rhs, "rhs");
			return checked(Duration.Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos));
		}

		public static Timestamp operator +(Timestamp lhs, Duration rhs)
		{
			ProtoPreconditions.CheckNotNull(lhs, "lhs");
			ProtoPreconditions.CheckNotNull(rhs, "rhs");
			return checked(Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos));
		}

		public static Timestamp operator -(Timestamp lhs, Duration rhs)
		{
			ProtoPreconditions.CheckNotNull(lhs, "lhs");
			ProtoPreconditions.CheckNotNull(rhs, "rhs");
			return checked(Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos));
		}

		public DateTime ToDateTime()
		{
			if (!IsNormalized(Seconds, Nanos))
			{
				throw new InvalidOperationException("Timestamp contains invalid values: Seconds={Seconds}; Nanos={Nanos}");
			}
			DateTime unixEpoch = UnixEpoch;
			return unixEpoch.AddSeconds(Seconds).AddTicks(Nanos / 100);
		}

		public DateTimeOffset ToDateTimeOffset()
		{
			return new DateTimeOffset(ToDateTime(), TimeSpan.Zero);
		}

		public static Timestamp FromDateTime(DateTime dateTime)
		{
			if (dateTime.Kind != DateTimeKind.Utc)
			{
				throw new ArgumentException("Conversion from DateTime to Timestamp requires the DateTime kind to be Utc", "dateTime");
			}
			long num = dateTime.Ticks / 10000000;
			int nanos = (int)(dateTime.Ticks % 10000000) * 100;
			return new Timestamp
			{
				Seconds = num - 62135596800L,
				Nanos = nanos
			};
		}

		public static Timestamp FromDateTimeOffset(DateTimeOffset dateTimeOffset)
		{
			return FromDateTime(dateTimeOffset.UtcDateTime);
		}

		internal static Timestamp Normalize(long seconds, int nanoseconds)
		{
			int num = nanoseconds / 1000000000;
			seconds += num;
			nanoseconds -= num * 1000000000;
			if (nanoseconds < 0)
			{
				nanoseconds += 1000000000;
				seconds--;
			}
			return new Timestamp
			{
				Seconds = seconds,
				Nanos = nanoseconds
			};
		}

		internal static string ToJson(long seconds, int nanoseconds, bool diagnosticOnly)
		{
			if (IsNormalized(seconds, nanoseconds))
			{
				DateTime unixEpoch = UnixEpoch;
				DateTime dateTime = unixEpoch.AddSeconds(seconds);
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('"');
				stringBuilder.Append(dateTime.ToString("yyyy'-'MM'-'dd'T'HH:mm:ss", CultureInfo.InvariantCulture));
				Duration.AppendNanoseconds(stringBuilder, nanoseconds);
				stringBuilder.Append("Z\"");
				return stringBuilder.ToString();
			}
			if (diagnosticOnly)
			{
				return string.Format(CultureInfo.InvariantCulture, "{{ \"@warning\": \"Invalid Timestamp\", \"seconds\": \"{0}\", \"nanos\": {1} }}", seconds, nanoseconds);
			}
			throw new InvalidOperationException("Non-normalized timestamp value");
		}

		public int CompareTo(Timestamp other)
		{
			if (!(other == null))
			{
				if (Seconds >= other.Seconds)
				{
					if (Seconds <= other.Seconds)
					{
						if (Nanos >= other.Nanos)
						{
							if (Nanos <= other.Nanos)
							{
								return 0;
							}
							return 1;
						}
						return -1;
					}
					return 1;
				}
				return -1;
			}
			return 1;
		}

		public static bool operator <(Timestamp a, Timestamp b)
		{
			return a.CompareTo(b) < 0;
		}

		public static bool operator >(Timestamp a, Timestamp b)
		{
			return a.CompareTo(b) > 0;
		}

		public static bool operator <=(Timestamp a, Timestamp b)
		{
			return a.CompareTo(b) <= 0;
		}

		public static bool operator >=(Timestamp a, Timestamp b)
		{
			return a.CompareTo(b) >= 0;
		}

		public static bool operator ==(Timestamp a, Timestamp b)
		{
			if ((object)a != b)
			{
				if ((object)a != null)
				{
					return a.Equals(b);
				}
				if ((object)b != null)
				{
					return false;
				}
				return true;
			}
			return true;
		}

		public static bool operator !=(Timestamp a, Timestamp b)
		{
			return !(a == b);
		}

		public string ToDiagnosticString()
		{
			return ToJson(Seconds, Nanos, diagnosticOnly: true);
		}
	}
	public static class TypeReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TypeReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Chpnb29nbGUvcHJvdG9idWYvdHlwZS5wcm90bxIPZ29vZ2xlLnByb3RvYnVm" + "Ghlnb29nbGUvcHJvdG9idWYvYW55LnByb3RvGiRnb29nbGUvcHJvdG9idWYv" + "c291cmNlX2NvbnRleHQucHJvdG8i1wEKBFR5cGUSDAoEbmFtZRgBIAEoCRIm" + "CgZmaWVsZHMYAiADKAsyFi5nb29nbGUucHJvdG9idWYuRmllbGQSDgoGb25l" + "b2ZzGAMgAygJEigKB29wdGlvbnMYBCADKAsyFy5nb29nbGUucHJvdG9idWYu" + "T3B0aW9uEjYKDnNvdXJjZV9jb250ZXh0GAUgASgLMh4uZ29vZ2xlLnByb3Rv" + "YnVmLlNvdXJjZUNvbnRleHQSJwoGc3ludGF4GAYgASgOMhcuZ29vZ2xlLnBy" + "b3RvYnVmLlN5bnRheCLVBQoFRmllbGQSKQoEa2luZBgBIAEoDjIbLmdvb2ds" + "ZS5wcm90b2J1Zi5GaWVsZC5LaW5kEjcKC2NhcmRpbmFsaXR5GAIgASgOMiIu" + "Z29vZ2xlLnByb3RvYnVmLkZpZWxkLkNhcmRpbmFsaXR5Eg4KBm51bWJlchgD" + "IAEoBRIMCgRuYW1lGAQgASgJEhAKCHR5cGVfdXJsGAYgASgJEhMKC29uZW9m" + "X2luZGV4GAcgASgFEg4KBnBhY2tlZBgIIAEoCBIoCgdvcHRpb25zGAkgAygL" + "MhcuZ29vZ2xlLnByb3RvYnVmLk9wdGlvbhIRCglqc29uX25hbWUYCiABKAkS" + "FQoNZGVmYXVsdF92YWx1ZRgLIAEoCSLIAgoES2luZBIQCgxUWVBFX1VOS05P" + "V04QABIPCgtUWVBFX0RPVUJMRRABEg4KClRZUEVfRkxPQVQQAhIOCgpUWVBF" + "X0lOVDY0EAMSDwoLVFlQRV9VSU5UNjQQBBIOCgpUWVBFX0lOVDMyEAUSEAoM" + "VFlQRV9GSVhFRDY0EAYSEAoMVFlQRV9GSVhFRDMyEAcSDQoJVFlQRV9CT09M" + "EAgSDwoLVFlQRV9TVFJJTkcQCRIOCgpUWVBFX0dST1VQEAoSEAoMVFlQRV9N" + "RVNTQUdFEAsSDgoKVFlQRV9CWVRFUxAMEg8KC1RZUEVfVUlOVDMyEA0SDQoJ" + "VFlQRV9FTlVNEA4SEQoNVFlQRV9TRklYRUQzMhAPEhEKDVRZUEVfU0ZJWEVE" + "NjQQEBIPCgtUWVBFX1NJTlQzMhAREg8KC1RZUEVfU0lOVDY0EBIidAoLQ2Fy" + "ZGluYWxpdHkSFwoTQ0FSRElOQUxJVFlfVU5LTk9XThAAEhgKFENBUkRJTkFM" + "SVRZX09QVElPTkFMEAESGAoUQ0FSRElOQUxJVFlfUkVRVUlSRUQQAhIYChRD" + "QVJESU5BTElUWV9SRVBFQVRFRBADIs4BCgRFbnVtEgwKBG5hbWUYASABKAkS" + "LQoJZW51bXZhbHVlGAIgAygLMhouZ29vZ2xlLnByb3RvYnVmLkVudW1WYWx1" + "ZRIoCgdvcHRpb25zGAMgAygLMhcuZ29vZ2xlLnByb3RvYnVmLk9wdGlvbhI2" + "Cg5zb3VyY2VfY29udGV4dBgEIAEoCzIeLmdvb2dsZS5wcm90b2J1Zi5Tb3Vy" + "Y2VDb250ZXh0EicKBnN5bnRheBgFIAEoDjIXLmdvb2dsZS5wcm90b2J1Zi5T" + "eW50YXgiUwoJRW51bVZhbHVlEgwKBG5hbWUYASABKAkSDgoGbnVtYmVyGAIg" + "ASgFEigKB29wdGlvbnMYAyADKAsyFy5nb29nbGUucHJvdG9idWYuT3B0aW9u" + "IjsKBk9wdGlvbhIMCgRuYW1lGAEgASgJEiMKBXZhbHVlGAIgASgLMhQuZ29v" + "Z2xlLnByb3RvYnVmLkFueSouCgZTeW50YXgSEQoNU1lOVEFYX1BST1RPMhAA" + "EhEKDVNZTlRBWF9QUk9UTzMQAUJ7ChNjb20uZ29vZ2xlLnByb3RvYnVmQglU" + "eXBlUHJvdG9QAVotZ29vZ2xlLmdvbGFuZy5vcmcvcHJvdG9idWYvdHlwZXMv" + "a25vd24vdHlwZXBi+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxL" + "bm93blR5cGVzYgZwcm90bzM="), new FileDescriptor[2]
			{
				AnyReflection.Descriptor,
				SourceContextReflection.Descriptor
			}, new GeneratedClrTypeInfo(new System.Type[1] { typeof(Syntax) }, null, new GeneratedClrTypeInfo[5]
			{
				new GeneratedClrTypeInfo(typeof(Type), Type.Parser, new string[6] { "Name", "Fields", "Oneofs", "Options", "SourceContext", "Syntax" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Field), Field.Parser, new string[10] { "Kind", "Cardinality", "Number", "Name", "TypeUrl", "OneofIndex", "Packed", "Options", "JsonName", "DefaultValue" }, null, new System.Type[2]
				{
					typeof(Field.Types.Kind),
					typeof(Field.Types.Cardinality)
				}, null, null),
				new GeneratedClrTypeInfo(typeof(Enum), Enum.Parser, new string[5] { "Name", "Enumvalue", "Options", "SourceContext", "Syntax" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(EnumValue), EnumValue.Parser, new string[3] { "Name", "Number", "Options" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Option), Option.Parser, new string[2] { "Name", "Value" }, null, null, null, null)
			}));
		}
	}
	public enum Syntax
	{
		[OriginalName("SYNTAX_PROTO2")]
		Proto2,
		[OriginalName("SYNTAX_PROTO3")]
		Proto3
	}
	public sealed class Type : IMessage<Type>, IMessage, IEquatable<Type>, IDeepCloneable<Type>, IBufferMessage
	{
		private static readonly MessageParser<Type> _parser = new MessageParser<Type>(() => new Type());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int FieldsFieldNumber = 2;

		private static readonly FieldCodec<Field> _repeated_fields_codec = FieldCodec.ForMessage(18u, Field.Parser);

		private readonly RepeatedField<Field> fields_ = new RepeatedField<Field>();

		public const int OneofsFieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_oneofs_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> oneofs_ = new RepeatedField<string>();

		public const int OptionsFieldNumber = 4;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(34u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		public const int SourceContextFieldNumber = 5;

		private SourceContext sourceContext_;

		public const int SyntaxFieldNumber = 6;

		private Syntax syntax_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Type> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TypeReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Field> Fields => fields_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<string> Oneofs => oneofs_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext SourceContext
		{
			get
			{
				return sourceContext_;
			}
			set
			{
				sourceContext_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Syntax Syntax
		{
			get
			{
				return syntax_;
			}
			set
			{
				syntax_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Type()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Type(Type other)
			: this()
		{
			name_ = other.name_;
			fields_ = other.fields_.Clone();
			oneofs_ = other.oneofs_.Clone();
			options_ = other.options_.Clone();
			sourceContext_ = ((other.sourceContext_ != null) ? other.sourceContext_.Clone() : null);
			syntax_ = other.syntax_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Type Clone()
		{
			return new Type(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Type);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Type other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!fields_.Equals(other.fields_))
			{
				return false;
			}
			if (!oneofs_.Equals(other.oneofs_))
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			if (!object.Equals(SourceContext, other.SourceContext))
			{
				return false;
			}
			if (Syntax != other.Syntax)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= fields_.GetHashCode();
			num ^= oneofs_.GetHashCode();
			num ^= options_.GetHashCode();
			if (sourceContext_ != null)
			{
				num ^= SourceContext.GetHashCode();
			}
			if (Syntax != Syntax.Proto2)
			{
				num ^= Syntax.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			fields_.WriteTo(ref output, _repeated_fields_codec);
			oneofs_.WriteTo(ref output, _repeated_oneofs_codec);
			options_.WriteTo(ref output, _repeated_options_codec);
			if (sourceContext_ != null)
			{
				output.WriteRawTag(42);
				output.WriteMessage(SourceContext);
			}
			if (Syntax != Syntax.Proto2)
			{
				output.WriteRawTag(48);
				output.WriteEnum((int)Syntax);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += fields_.CalculateSize(_repeated_fields_codec);
			num += oneofs_.CalculateSize(_repeated_oneofs_codec);
			num += options_.CalculateSize(_repeated_options_codec);
			if (sourceContext_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(SourceContext);
			}
			if (Syntax != Syntax.Proto2)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Syntax);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Type other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			fields_.Add(other.fields_);
			oneofs_.Add(other.oneofs_);
			options_.Add(other.options_);
			if (other.sourceContext_ != null)
			{
				if (sourceContext_ == null)
				{
					SourceContext = new SourceContext();
				}
				SourceContext.MergeFrom(other.SourceContext);
			}
			if (other.Syntax != Syntax.Proto2)
			{
				Syntax = other.Syntax;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					fields_.AddEntriesFrom(ref input, _repeated_fields_codec);
					break;
				case 26u:
					oneofs_.AddEntriesFrom(ref input, _repeated_oneofs_codec);
					break;
				case 34u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				case 42u:
					if (sourceContext_ == null)
					{
						SourceContext = new SourceContext();
					}
					input.ReadMessage(SourceContext);
					break;
				case 48u:
					Syntax = (Syntax)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class Field : IMessage<Field>, IMessage, IEquatable<Field>, IDeepCloneable<Field>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public enum Kind
			{
				[OriginalName("TYPE_UNKNOWN")]
				TypeUnknown,
				[OriginalName("TYPE_DOUBLE")]
				TypeDouble,
				[OriginalName("TYPE_FLOAT")]
				TypeFloat,
				[OriginalName("TYPE_INT64")]
				TypeInt64,
				[OriginalName("TYPE_UINT64")]
				TypeUint64,
				[OriginalName("TYPE_INT32")]
				TypeInt32,
				[OriginalName("TYPE_FIXED64")]
				TypeFixed64,
				[OriginalName("TYPE_FIXED32")]
				TypeFixed32,
				[OriginalName("TYPE_BOOL")]
				TypeBool,
				[OriginalName("TYPE_STRING")]
				TypeString,
				[OriginalName("TYPE_GROUP")]
				TypeGroup,
				[OriginalName("TYPE_MESSAGE")]
				TypeMessage,
				[OriginalName("TYPE_BYTES")]
				TypeBytes,
				[OriginalName("TYPE_UINT32")]
				TypeUint32,
				[OriginalName("TYPE_ENUM")]
				TypeEnum,
				[OriginalName("TYPE_SFIXED32")]
				TypeSfixed32,
				[OriginalName("TYPE_SFIXED64")]
				TypeSfixed64,
				[OriginalName("TYPE_SINT32")]
				TypeSint32,
				[OriginalName("TYPE_SINT64")]
				TypeSint64
			}

			public enum Cardinality
			{
				[OriginalName("CARDINALITY_UNKNOWN")]
				Unknown,
				[OriginalName("CARDINALITY_OPTIONAL")]
				Optional,
				[OriginalName("CARDINALITY_REQUIRED")]
				Required,
				[OriginalName("CARDINALITY_REPEATED")]
				Repeated
			}
		}

		private static readonly MessageParser<Field> _parser = new MessageParser<Field>(() => new Field());

		private UnknownFieldSet _unknownFields;

		public const int KindFieldNumber = 1;

		private Types.Kind kind_;

		public const int CardinalityFieldNumber = 2;

		private Types.Cardinality cardinality_;

		public const int NumberFieldNumber = 3;

		private int number_;

		public const int NameFieldNumber = 4;

		private string name_ = "";

		public const int TypeUrlFieldNumber = 6;

		private string typeUrl_ = "";

		public const int OneofIndexFieldNumber = 7;

		private int oneofIndex_;

		public const int PackedFieldNumber = 8;

		private bool packed_;

		public const int OptionsFieldNumber = 9;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(74u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		public const int JsonNameFieldNumber = 10;

		private string jsonName_ = "";

		public const int DefaultValueFieldNumber = 11;

		private string defaultValue_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Field> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TypeReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.Kind Kind
		{
			get
			{
				return kind_;
			}
			set
			{
				kind_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.Cardinality Cardinality
		{
			get
			{
				return cardinality_;
			}
			set
			{
				cardinality_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Number
		{
			get
			{
				return number_;
			}
			set
			{
				number_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string TypeUrl
		{
			get
			{
				return typeUrl_;
			}
			set
			{
				typeUrl_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int OneofIndex
		{
			get
			{
				return oneofIndex_;
			}
			set
			{
				oneofIndex_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Packed
		{
			get
			{
				return packed_;
			}
			set
			{
				packed_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string JsonName
		{
			get
			{
				return jsonName_;
			}
			set
			{
				jsonName_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string DefaultValue
		{
			get
			{
				return defaultValue_;
			}
			set
			{
				defaultValue_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Field()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Field(Field other)
			: this()
		{
			kind_ = other.kind_;
			cardinality_ = other.cardinality_;
			number_ = other.number_;
			name_ = other.name_;
			typeUrl_ = other.typeUrl_;
			oneofIndex_ = other.oneofIndex_;
			packed_ = other.packed_;
			options_ = other.options_.Clone();
			jsonName_ = other.jsonName_;
			defaultValue_ = other.defaultValue_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Field Clone()
		{
			return new Field(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Field);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Field other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Kind != other.Kind)
			{
				return false;
			}
			if (Cardinality != other.Cardinality)
			{
				return false;
			}
			if (Number != other.Number)
			{
				return false;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (TypeUrl != other.TypeUrl)
			{
				return false;
			}
			if (OneofIndex != other.OneofIndex)
			{
				return false;
			}
			if (Packed != other.Packed)
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			if (JsonName != other.JsonName)
			{
				return false;
			}
			if (DefaultValue != other.DefaultValue)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Kind != Types.Kind.TypeUnknown)
			{
				num ^= Kind.GetHashCode();
			}
			if (Cardinality != Types.Cardinality.Unknown)
			{
				num ^= Cardinality.GetHashCode();
			}
			if (Number != 0)
			{
				num ^= Number.GetHashCode();
			}
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (TypeUrl.Length != 0)
			{
				num ^= TypeUrl.GetHashCode();
			}
			if (OneofIndex != 0)
			{
				num ^= OneofIndex.GetHashCode();
			}
			if (Packed)
			{
				num ^= Packed.GetHashCode();
			}
			num ^= options_.GetHashCode();
			if (JsonName.Length != 0)
			{
				num ^= JsonName.GetHashCode();
			}
			if (DefaultValue.Length != 0)
			{
				num ^= DefaultValue.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Kind != Types.Kind.TypeUnknown)
			{
				output.WriteRawTag(8);
				output.WriteEnum((int)Kind);
			}
			if (Cardinality != Types.Cardinality.Unknown)
			{
				output.WriteRawTag(16);
				output.WriteEnum((int)Cardinality);
			}
			if (Number != 0)
			{
				output.WriteRawTag(24);
				output.WriteInt32(Number);
			}
			if (Name.Length != 0)
			{
				output.WriteRawTag(34);
				output.WriteString(Name);
			}
			if (TypeUrl.Length != 0)
			{
				output.WriteRawTag(50);
				output.WriteString(TypeUrl);
			}
			if (OneofIndex != 0)
			{
				output.WriteRawTag(56);
				output.WriteInt32(OneofIndex);
			}
			if (Packed)
			{
				output.WriteRawTag(64);
				output.WriteBool(Packed);
			}
			options_.WriteTo(ref output, _repeated_options_codec);
			if (JsonName.Length != 0)
			{
				output.WriteRawTag(82);
				output.WriteString(JsonName);
			}
			if (DefaultValue.Length != 0)
			{
				output.WriteRawTag(90);
				output.WriteString(DefaultValue);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Kind != Types.Kind.TypeUnknown)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Kind);
			}
			if (Cardinality != Types.Cardinality.Unknown)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Cardinality);
			}
			if (Number != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Number);
			}
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (TypeUrl.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeUrl);
			}
			if (OneofIndex != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(OneofIndex);
			}
			if (Packed)
			{
				num += 2;
			}
			num += options_.CalculateSize(_repeated_options_codec);
			if (JsonName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(JsonName);
			}
			if (DefaultValue.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DefaultValue);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Field other)
		{
			if (other != null)
			{
				if (other.Kind != Types.Kind.TypeUnknown)
				{
					Kind = other.Kind;
				}
				if (other.Cardinality != Types.Cardinality.Unknown)
				{
					Cardinality = other.Cardinality;
				}
				if (other.Number != 0)
				{
					Number = other.Number;
				}
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.TypeUrl.Length != 0)
				{
					TypeUrl = other.TypeUrl;
				}
				if (other.OneofIndex != 0)
				{
					OneofIndex = other.OneofIndex;
				}
				if (other.Packed)
				{
					Packed = other.Packed;
				}
				options_.Add(other.options_);
				if (other.JsonName.Length != 0)
				{
					JsonName = other.JsonName;
				}
				if (other.DefaultValue.Length != 0)
				{
					DefaultValue = other.DefaultValue;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 8u:
					Kind = (Types.Kind)input.ReadEnum();
					break;
				case 16u:
					Cardinality = (Types.Cardinality)input.ReadEnum();
					break;
				case 24u:
					Number = input.ReadInt32();
					break;
				case 34u:
					Name = input.ReadString();
					break;
				case 50u:
					TypeUrl = input.ReadString();
					break;
				case 56u:
					OneofIndex = input.ReadInt32();
					break;
				case 64u:
					Packed = input.ReadBool();
					break;
				case 74u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				case 82u:
					JsonName = input.ReadString();
					break;
				case 90u:
					DefaultValue = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class Enum : IMessage<Enum>, IMessage, IEquatable<Enum>, IDeepCloneable<Enum>, IBufferMessage
	{
		private static readonly MessageParser<Enum> _parser = new MessageParser<Enum>(() => new Enum());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int EnumvalueFieldNumber = 2;

		private static readonly FieldCodec<EnumValue> _repeated_enumvalue_codec = FieldCodec.ForMessage(18u, EnumValue.Parser);

		private readonly RepeatedField<EnumValue> enumvalue_ = new RepeatedField<EnumValue>();

		public const int OptionsFieldNumber = 3;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(26u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		public const int SourceContextFieldNumber = 4;

		private SourceContext sourceContext_;

		public const int SyntaxFieldNumber = 5;

		private Syntax syntax_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Enum> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TypeReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<EnumValue> Enumvalue => enumvalue_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceContext SourceContext
		{
			get
			{
				return sourceContext_;
			}
			set
			{
				sourceContext_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Syntax Syntax
		{
			get
			{
				return syntax_;
			}
			set
			{
				syntax_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Enum()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Enum(Enum other)
			: this()
		{
			name_ = other.name_;
			enumvalue_ = other.enumvalue_.Clone();
			options_ = other.options_.Clone();
			sourceContext_ = ((other.sourceContext_ != null) ? other.sourceContext_.Clone() : null);
			syntax_ = other.syntax_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Enum Clone()
		{
			return new Enum(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Enum);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Enum other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!enumvalue_.Equals(other.enumvalue_))
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			if (!object.Equals(SourceContext, other.SourceContext))
			{
				return false;
			}
			if (Syntax != other.Syntax)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= enumvalue_.GetHashCode();
			num ^= options_.GetHashCode();
			if (sourceContext_ != null)
			{
				num ^= SourceContext.GetHashCode();
			}
			if (Syntax != Syntax.Proto2)
			{
				num ^= Syntax.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			enumvalue_.WriteTo(ref output, _repeated_enumvalue_codec);
			options_.WriteTo(ref output, _repeated_options_codec);
			if (sourceContext_ != null)
			{
				output.WriteRawTag(34);
				output.WriteMessage(SourceContext);
			}
			if (Syntax != Syntax.Proto2)
			{
				output.WriteRawTag(40);
				output.WriteEnum((int)Syntax);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += enumvalue_.CalculateSize(_repeated_enumvalue_codec);
			num += options_.CalculateSize(_repeated_options_codec);
			if (sourceContext_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(SourceContext);
			}
			if (Syntax != Syntax.Proto2)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Syntax);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Enum other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			enumvalue_.Add(other.enumvalue_);
			options_.Add(other.options_);
			if (other.sourceContext_ != null)
			{
				if (sourceContext_ == null)
				{
					SourceContext = new SourceContext();
				}
				SourceContext.MergeFrom(other.SourceContext);
			}
			if (other.Syntax != Syntax.Proto2)
			{
				Syntax = other.Syntax;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					enumvalue_.AddEntriesFrom(ref input, _repeated_enumvalue_codec);
					break;
				case 26u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				case 34u:
					if (sourceContext_ == null)
					{
						SourceContext = new SourceContext();
					}
					input.ReadMessage(SourceContext);
					break;
				case 40u:
					Syntax = (Syntax)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class EnumValue : IMessage<EnumValue>, IMessage, IEquatable<EnumValue>, IDeepCloneable<EnumValue>, IBufferMessage
	{
		private static readonly MessageParser<EnumValue> _parser = new MessageParser<EnumValue>(() => new EnumValue());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int NumberFieldNumber = 2;

		private int number_;

		public const int OptionsFieldNumber = 3;

		private static readonly FieldCodec<Option> _repeated_options_codec = FieldCodec.ForMessage(26u, Option.Parser);

		private readonly RepeatedField<Option> options_ = new RepeatedField<Option>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<EnumValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TypeReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Number
		{
			get
			{
				return number_;
			}
			set
			{
				number_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Option> Options => options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValue(EnumValue other)
			: this()
		{
			name_ = other.name_;
			number_ = other.number_;
			options_ = other.options_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValue Clone()
		{
			return new EnumValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as EnumValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(EnumValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Number != other.Number)
			{
				return false;
			}
			if (!options_.Equals(other.options_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Number != 0)
			{
				num ^= Number.GetHashCode();
			}
			num ^= options_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (Number != 0)
			{
				output.WriteRawTag(16);
				output.WriteInt32(Number);
			}
			options_.WriteTo(ref output, _repeated_options_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Number != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Number);
			}
			num += options_.CalculateSize(_repeated_options_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(EnumValue other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.Number != 0)
				{
					Number = other.Number;
				}
				options_.Add(other.options_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 16u:
					Number = input.ReadInt32();
					break;
				case 26u:
					options_.AddEntriesFrom(ref input, _repeated_options_codec);
					break;
				}
			}
		}
	}
	public sealed class Option : IMessage<Option>, IMessage, IEquatable<Option>, IDeepCloneable<Option>, IBufferMessage
	{
		private static readonly MessageParser<Option> _parser = new MessageParser<Option>(() => new Option());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ValueFieldNumber = 2;

		private Any value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Option> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => TypeReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Any Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Option()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Option(Option other)
			: this()
		{
			name_ = other.name_;
			value_ = ((other.value_ != null) ? other.value_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Option Clone()
		{
			return new Option(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Option);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Option other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!object.Equals(Value, other.Value))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (value_ != null)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (value_ != null)
			{
				output.WriteRawTag(18);
				output.WriteMessage(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (value_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Option other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.value_ != null)
			{
				if (value_ == null)
				{
					Value = new Any();
				}
				Value.MergeFrom(other.Value);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					if (value_ == null)
					{
						Value = new Any();
					}
					input.ReadMessage(Value);
					break;
				}
			}
		}
	}
	public static class WrappersReflection
	{
		private static FileDescriptor descriptor;

		internal const int WrapperValueFieldNumber = 1;

		public static FileDescriptor Descriptor => descriptor;

		static WrappersReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ch5nb29nbGUvcHJvdG9idWYvd3JhcHBlcnMucHJvdG8SD2dvb2dsZS5wcm90" + "b2J1ZiIcCgtEb3VibGVWYWx1ZRINCgV2YWx1ZRgBIAEoASIbCgpGbG9hdFZh" + "bHVlEg0KBXZhbHVlGAEgASgCIhsKCkludDY0VmFsdWUSDQoFdmFsdWUYASAB" + "KAMiHAoLVUludDY0VmFsdWUSDQoFdmFsdWUYASABKAQiGwoKSW50MzJWYWx1" + "ZRINCgV2YWx1ZRgBIAEoBSIcCgtVSW50MzJWYWx1ZRINCgV2YWx1ZRgBIAEo" + "DSIaCglCb29sVmFsdWUSDQoFdmFsdWUYASABKAgiHAoLU3RyaW5nVmFsdWUS" + "DQoFdmFsdWUYASABKAkiGwoKQnl0ZXNWYWx1ZRINCgV2YWx1ZRgBIAEoDEKD" + "AQoTY29tLmdvb2dsZS5wcm90b2J1ZkINV3JhcHBlcnNQcm90b1ABWjFnb29n" + "bGUuZ29sYW5nLm9yZy9wcm90b2J1Zi90eXBlcy9rbm93bi93cmFwcGVyc3Bi" + "+AEBogIDR1BCqgIeR29vZ2xlLlByb3RvYnVmLldlbGxLbm93blR5cGVzYgZw" + "cm90bzM="), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[9]
			{
				new GeneratedClrTypeInfo(typeof(DoubleValue), DoubleValue.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(FloatValue), FloatValue.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Int64Value), Int64Value.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(UInt64Value), UInt64Value.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(Int32Value), Int32Value.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(UInt32Value), UInt32Value.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(BoolValue), BoolValue.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(StringValue), StringValue.Parser, new string[1] { "Value" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(BytesValue), BytesValue.Parser, new string[1] { "Value" }, null, null, null, null)
			}));
		}
	}
	public sealed class DoubleValue : IMessage<DoubleValue>, IMessage, IEquatable<DoubleValue>, IDeepCloneable<DoubleValue>, IBufferMessage
	{
		private static readonly MessageParser<DoubleValue> _parser = new MessageParser<DoubleValue>(() => new DoubleValue());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private double value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<DoubleValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public double Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DoubleValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DoubleValue(DoubleValue other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DoubleValue Clone()
		{
			return new DoubleValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as DoubleValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(DoubleValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Value, other.Value))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Value);
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0.0)
			{
				output.WriteRawTag(9);
				output.WriteDouble(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0.0)
			{
				num += 9;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(DoubleValue other)
		{
			if (other != null)
			{
				if (other.Value != 0.0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 9)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadDouble();
				}
			}
		}
	}
	public sealed class FloatValue : IMessage<FloatValue>, IMessage, IEquatable<FloatValue>, IDeepCloneable<FloatValue>, IBufferMessage
	{
		private static readonly MessageParser<FloatValue> _parser = new MessageParser<FloatValue>(() => new FloatValue());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private float value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FloatValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public float Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FloatValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FloatValue(FloatValue other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FloatValue Clone()
		{
			return new FloatValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FloatValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FloatValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Value, other.Value))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Value);
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0f)
			{
				output.WriteRawTag(13);
				output.WriteFloat(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0f)
			{
				num += 5;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FloatValue other)
		{
			if (other != null)
			{
				if (other.Value != 0f)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 13)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadFloat();
				}
			}
		}
	}
	public sealed class Int64Value : IMessage<Int64Value>, IMessage, IEquatable<Int64Value>, IDeepCloneable<Int64Value>, IBufferMessage
	{
		private static readonly MessageParser<Int64Value> _parser = new MessageParser<Int64Value>(() => new Int64Value());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private long value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Int64Value> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public long Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int64Value()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int64Value(Int64Value other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int64Value Clone()
		{
			return new Int64Value(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Int64Value);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Int64Value other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0L)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0L)
			{
				output.WriteRawTag(8);
				output.WriteInt64(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Int64Value other)
		{
			if (other != null)
			{
				if (other.Value != 0L)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadInt64();
				}
			}
		}
	}
	public sealed class UInt64Value : IMessage<UInt64Value>, IMessage, IEquatable<UInt64Value>, IDeepCloneable<UInt64Value>, IBufferMessage
	{
		private static readonly MessageParser<UInt64Value> _parser = new MessageParser<UInt64Value>(() => new UInt64Value());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private ulong value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<UInt64Value> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ulong Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt64Value()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt64Value(UInt64Value other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt64Value Clone()
		{
			return new UInt64Value(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as UInt64Value);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(UInt64Value other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0L)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0L)
			{
				output.WriteRawTag(8);
				output.WriteUInt64(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0L)
			{
				num += 1 + CodedOutputStream.ComputeUInt64Size(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(UInt64Value other)
		{
			if (other != null)
			{
				if (other.Value != 0L)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadUInt64();
				}
			}
		}
	}
	public sealed class Int32Value : IMessage<Int32Value>, IMessage, IEquatable<Int32Value>, IDeepCloneable<Int32Value>, IBufferMessage
	{
		private static readonly MessageParser<Int32Value> _parser = new MessageParser<Int32Value>(() => new Int32Value());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private int value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<Int32Value> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int32Value()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int32Value(Int32Value other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Int32Value Clone()
		{
			return new Int32Value(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as Int32Value);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(Int32Value other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0)
			{
				output.WriteRawTag(8);
				output.WriteInt32(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(Int32Value other)
		{
			if (other != null)
			{
				if (other.Value != 0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadInt32();
				}
			}
		}
	}
	public sealed class UInt32Value : IMessage<UInt32Value>, IMessage, IEquatable<UInt32Value>, IDeepCloneable<UInt32Value>, IBufferMessage
	{
		private static readonly MessageParser<UInt32Value> _parser = new MessageParser<UInt32Value>(() => new UInt32Value());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private uint value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<UInt32Value> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public uint Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt32Value()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt32Value(UInt32Value other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UInt32Value Clone()
		{
			return new UInt32Value(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as UInt32Value);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(UInt32Value other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value != 0)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value != 0)
			{
				output.WriteRawTag(8);
				output.WriteUInt32(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value != 0)
			{
				num += 1 + CodedOutputStream.ComputeUInt32Size(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(UInt32Value other)
		{
			if (other != null)
			{
				if (other.Value != 0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadUInt32();
				}
			}
		}
	}
	public sealed class BoolValue : IMessage<BoolValue>, IMessage, IEquatable<BoolValue>, IDeepCloneable<BoolValue>, IBufferMessage
	{
		private static readonly MessageParser<BoolValue> _parser = new MessageParser<BoolValue>(() => new BoolValue());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private bool value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BoolValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BoolValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BoolValue(BoolValue other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BoolValue Clone()
		{
			return new BoolValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BoolValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BoolValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value)
			{
				output.WriteRawTag(8);
				output.WriteBool(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BoolValue other)
		{
			if (other != null)
			{
				if (other.Value)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadBool();
				}
			}
		}
	}
	public sealed class StringValue : IMessage<StringValue>, IMessage, IEquatable<StringValue>, IDeepCloneable<StringValue>, IBufferMessage
	{
		private static readonly MessageParser<StringValue> _parser = new MessageParser<StringValue>(() => new StringValue());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private string value_ = "";

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<StringValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public StringValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public StringValue(StringValue other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public StringValue Clone()
		{
			return new StringValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as StringValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(StringValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value.Length != 0)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteString(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(StringValue other)
		{
			if (other != null)
			{
				if (other.Value.Length != 0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadString();
				}
			}
		}
	}
	public sealed class BytesValue : IMessage<BytesValue>, IMessage, IEquatable<BytesValue>, IDeepCloneable<BytesValue>, IBufferMessage
	{
		private static readonly MessageParser<BytesValue> _parser = new MessageParser<BytesValue>(() => new BytesValue());

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private ByteString value_ = ByteString.Empty;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<BytesValue> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => WrappersReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ByteString Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BytesValue()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BytesValue(BytesValue other)
			: this()
		{
			value_ = other.value_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public BytesValue Clone()
		{
			return new BytesValue(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as BytesValue);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(BytesValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Value != other.Value)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (Value.Length != 0)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (Value.Length != 0)
			{
				output.WriteRawTag(10);
				output.WriteBytes(Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (Value.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(BytesValue other)
		{
			if (other != null)
			{
				if (other.Value.Length != 0)
				{
					Value = other.Value;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					Value = input.ReadBytes();
				}
			}
		}
	}
}
namespace Google.Protobuf.Reflection
{
	public sealed class CustomOptions
	{
		private const string UnreferencedCodeMessage = "CustomOptions is incompatible with trimming.";

		private static readonly object[] EmptyParameters = new object[0];

		private readonly IDictionary<int, IExtensionValue> values;

		internal CustomOptions(IDictionary<int, IExtensionValue> values)
		{
			this.values = values;
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetBool(int field, out bool value)
		{
			return TryGetPrimitiveValue<bool>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetInt32(int field, out int value)
		{
			return TryGetPrimitiveValue<int>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetInt64(int field, out long value)
		{
			return TryGetPrimitiveValue<long>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetFixed32(int field, out uint value)
		{
			return TryGetUInt32(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetFixed64(int field, out ulong value)
		{
			return TryGetUInt64(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetSFixed32(int field, out int value)
		{
			return TryGetInt32(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetSFixed64(int field, out long value)
		{
			return TryGetInt64(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetSInt32(int field, out int value)
		{
			return TryGetPrimitiveValue<int>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetSInt64(int field, out long value)
		{
			return TryGetPrimitiveValue<long>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetUInt32(int field, out uint value)
		{
			return TryGetPrimitiveValue<uint>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetUInt64(int field, out ulong value)
		{
			return TryGetPrimitiveValue<ulong>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetFloat(int field, out float value)
		{
			return TryGetPrimitiveValue<float>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetDouble(int field, out double value)
		{
			return TryGetPrimitiveValue<double>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetString(int field, out string value)
		{
			return TryGetPrimitiveValue<string>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetBytes(int field, out ByteString value)
		{
			return TryGetPrimitiveValue<ByteString>(field, out value);
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		public bool TryGetMessage<T>(int field, out T value) where T : class, IMessage, new()
		{
			if (values == null)
			{
				value = null;
				return false;
			}
			if (values.TryGetValue(field, out var value2))
			{
				if (value2 is ExtensionValue<T>)
				{
					ByteString data = (value2 as ExtensionValue<T>).GetValue().ToByteString();
					value = new T();
					value.MergeFrom(data);
					return true;
				}
				if (value2 is RepeatedExtensionValue<T>)
				{
					RepeatedExtensionValue<T> repeatedExtensionValue = value2 as RepeatedExtensionValue<T>;
					value = (from v in repeatedExtensionValue.GetValue()
						select v.ToByteString()).Aggregate(new T(), delegate(T t, ByteString b)
					{
						t.MergeFrom(b);
						return t;
					});
					return true;
				}
			}
			value = null;
			return false;
		}

		[RequiresUnreferencedCode("CustomOptions is incompatible with trimming.")]
		private bool TryGetPrimitiveValue<T>(int field, out T value)
		{
			if (values == null)
			{
				value = default(T);
				return false;
			}
			if (values.TryGetValue(field, out var value2))
			{
				if (value2 is ExtensionValue<T>)
				{
					ExtensionValue<T> extensionValue = value2 as ExtensionValue<T>;
					value = extensionValue.GetValue();
					return true;
				}
				if (value2 is RepeatedExtensionValue<T>)
				{
					RepeatedExtensionValue<T> repeatedExtensionValue = value2 as RepeatedExtensionValue<T>;
					if (repeatedExtensionValue.GetValue().Count != 0)
					{
						RepeatedField<T> value3 = repeatedExtensionValue.GetValue();
						value = value3[value3.Count - 1];
						return true;
					}
				}
				else
				{
					System.Type type = value2.GetType();
					if (type.GetGenericTypeDefinition() == typeof(ExtensionValue<>))
					{
						TypeInfo typeInfo = type.GetTypeInfo();
						System.Type[] genericTypeArguments = typeInfo.GenericTypeArguments;
						if (genericTypeArguments.Length == 1 && genericTypeArguments[0].GetTypeInfo().IsEnum)
						{
							value = (T)typeInfo.GetDeclaredMethod("GetValue").Invoke(value2, EmptyParameters);
							return true;
						}
					}
					else if (type.GetGenericTypeDefinition() == typeof(RepeatedExtensionValue<>))
					{
						TypeInfo typeInfo2 = type.GetTypeInfo();
						System.Type[] genericTypeArguments2 = typeInfo2.GenericTypeArguments;
						if (genericTypeArguments2.Length == 1 && genericTypeArguments2[0].GetTypeInfo().IsEnum)
						{
							IList list = (IList)typeInfo2.GetDeclaredMethod("GetValue").Invoke(value2, EmptyParameters);
							if (list.Count != 0)
							{
								value = (T)list[list.Count - 1];
								return true;
							}
						}
					}
				}
			}
			value = default(T);
			return false;
		}
	}
	public static class DescriptorReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static DescriptorReflection()
		{
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxIPZ29vZ2xlLnBy" + "b3RvYnVmIkcKEUZpbGVEZXNjcmlwdG9yU2V0EjIKBGZpbGUYASADKAsyJC5n" + "b29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90byLbAwoTRmlsZURl" + "c2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg8KB3BhY2thZ2UYAiABKAkS" + "EgoKZGVwZW5kZW5jeRgDIAMoCRIZChFwdWJsaWNfZGVwZW5kZW5jeRgKIAMo" + "BRIXCg93ZWFrX2RlcGVuZGVuY3kYCyADKAUSNgoMbWVzc2FnZV90eXBlGAQg" + "AygLMiAuZ29vZ2xlLnByb3RvYnVmLkRlc2NyaXB0b3JQcm90bxI3CgllbnVt" + "X3R5cGUYBSADKAsyJC5nb29nbGUucHJvdG9idWYuRW51bURlc2NyaXB0b3JQ" + "cm90bxI4CgdzZXJ2aWNlGAYgAygLMicuZ29vZ2xlLnByb3RvYnVmLlNlcnZp" + "Y2VEZXNjcmlwdG9yUHJvdG8SOAoJZXh0ZW5zaW9uGAcgAygLMiUuZ29vZ2xl" + "LnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvEi0KB29wdGlvbnMYCCAB" + "KAsyHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMSOQoQc291cmNlX2Nv" + "ZGVfaW5mbxgJIAEoCzIfLmdvb2dsZS5wcm90b2J1Zi5Tb3VyY2VDb2RlSW5m" + "bxIOCgZzeW50YXgYDCABKAkiqQUKD0Rlc2NyaXB0b3JQcm90bxIMCgRuYW1l" + "GAEgASgJEjQKBWZpZWxkGAIgAygLMiUuZ29vZ2xlLnByb3RvYnVmLkZpZWxk" + "RGVzY3JpcHRvclByb3RvEjgKCWV4dGVuc2lvbhgGIAMoCzIlLmdvb2dsZS5w" + "cm90b2J1Zi5GaWVsZERlc2NyaXB0b3JQcm90bxI1CgtuZXN0ZWRfdHlwZRgD" + "IAMoCzIgLmdvb2dsZS5wcm90b2J1Zi5EZXNjcmlwdG9yUHJvdG8SNwoJZW51" + "bV90eXBlGAQgAygLMiQuZ29vZ2xlLnByb3RvYnVmLkVudW1EZXNjcmlwdG9y" + "UHJvdG8SSAoPZXh0ZW5zaW9uX3JhbmdlGAUgAygLMi8uZ29vZ2xlLnByb3Rv" + "YnVmLkRlc2NyaXB0b3JQcm90by5FeHRlbnNpb25SYW5nZRI5CgpvbmVvZl9k" + "ZWNsGAggAygLMiUuZ29vZ2xlLnByb3RvYnVmLk9uZW9mRGVzY3JpcHRvclBy" + "b3RvEjAKB29wdGlvbnMYByABKAsyHy5nb29nbGUucHJvdG9idWYuTWVzc2Fn" + "ZU9wdGlvbnMSRgoOcmVzZXJ2ZWRfcmFuZ2UYCSADKAsyLi5nb29nbGUucHJv" + "dG9idWYuRGVzY3JpcHRvclByb3RvLlJlc2VydmVkUmFuZ2USFQoNcmVzZXJ2" + "ZWRfbmFtZRgKIAMoCRplCg5FeHRlbnNpb25SYW5nZRINCgVzdGFydBgBIAEo" + "BRILCgNlbmQYAiABKAUSNwoHb3B0aW9ucxgDIAEoCzImLmdvb2dsZS5wcm90" + "b2J1Zi5FeHRlbnNpb25SYW5nZU9wdGlvbnMaKwoNUmVzZXJ2ZWRSYW5nZRIN" + "CgVzdGFydBgBIAEoBRILCgNlbmQYAiABKAUiZwoVRXh0ZW5zaW9uUmFuZ2VP" + "cHRpb25zEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMoCzIkLmdvb2ds" + "ZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uKgkI6AcQgICAgAIi1QUK" + "FEZpZWxkRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSDgoGbnVtYmVy" + "GAMgASgFEjoKBWxhYmVsGAQgASgOMisuZ29vZ2xlLnByb3RvYnVmLkZpZWxk" + "RGVzY3JpcHRvclByb3RvLkxhYmVsEjgKBHR5cGUYBSABKA4yKi5nb29nbGUu" + "cHJvdG9idWYuRmllbGREZXNjcmlwdG9yUHJvdG8uVHlwZRIRCgl0eXBlX25h" + "bWUYBiABKAkSEAoIZXh0ZW5kZWUYAiABKAkSFQoNZGVmYXVsdF92YWx1ZRgH" + "IAEoCRITCgtvbmVvZl9pbmRleBgJIAEoBRIRCglqc29uX25hbWUYCiABKAkS" + "LgoHb3B0aW9ucxgIIAEoCzIdLmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlv" + "bnMSFwoPcHJvdG8zX29wdGlvbmFsGBEgASgIIrYCCgRUeXBlEg8KC1RZUEVf" + "RE9VQkxFEAESDgoKVFlQRV9GTE9BVBACEg4KClRZUEVfSU5UNjQQAxIPCgtU" + "WVBFX1VJTlQ2NBAEEg4KClRZUEVfSU5UMzIQBRIQCgxUWVBFX0ZJWEVENjQQ" + "BhIQCgxUWVBFX0ZJWEVEMzIQBxINCglUWVBFX0JPT0wQCBIPCgtUWVBFX1NU" + "UklORxAJEg4KClRZUEVfR1JPVVAQChIQCgxUWVBFX01FU1NBR0UQCxIOCgpU" + "WVBFX0JZVEVTEAwSDwoLVFlQRV9VSU5UMzIQDRINCglUWVBFX0VOVU0QDhIR" + "Cg1UWVBFX1NGSVhFRDMyEA8SEQoNVFlQRV9TRklYRUQ2NBAQEg8KC1RZUEVf" + "U0lOVDMyEBESDwoLVFlQRV9TSU5UNjQQEiJDCgVMYWJlbBISCg5MQUJFTF9P" + "UFRJT05BTBABEhIKDkxBQkVMX1JFUVVJUkVEEAISEgoOTEFCRUxfUkVQRUFU" + "RUQQAyJUChRPbmVvZkRlc2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEi4K" + "B29wdGlvbnMYAiABKAsyHS5nb29nbGUucHJvdG9idWYuT25lb2ZPcHRpb25z" + "IqQCChNFbnVtRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSOAoFdmFs" + "dWUYAiADKAsyKS5nb29nbGUucHJvdG9idWYuRW51bVZhbHVlRGVzY3JpcHRv" + "clByb3RvEi0KB29wdGlvbnMYAyABKAsyHC5nb29nbGUucHJvdG9idWYuRW51" + "bU9wdGlvbnMSTgoOcmVzZXJ2ZWRfcmFuZ2UYBCADKAsyNi5nb29nbGUucHJv" + "dG9idWYuRW51bURlc2NyaXB0b3JQcm90by5FbnVtUmVzZXJ2ZWRSYW5nZRIV" + "Cg1yZXNlcnZlZF9uYW1lGAUgAygJGi8KEUVudW1SZXNlcnZlZFJhbmdlEg0K" + "BXN0YXJ0GAEgASgFEgsKA2VuZBgCIAEoBSJsChhFbnVtVmFsdWVEZXNjcmlw" + "dG9yUHJvdG8SDAoEbmFtZRgBIAEoCRIOCgZudW1iZXIYAiABKAUSMgoHb3B0" + "aW9ucxgDIAEoCzIhLmdvb2dsZS5wcm90b2J1Zi5FbnVtVmFsdWVPcHRpb25z" + "IpABChZTZXJ2aWNlRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSNgoG" + "bWV0aG9kGAIgAygLMiYuZ29vZ2xlLnByb3RvYnVmLk1ldGhvZERlc2NyaXB0" + "b3JQcm90bxIwCgdvcHRpb25zGAMgASgLMh8uZ29vZ2xlLnByb3RvYnVmLlNl" + "cnZpY2VPcHRpb25zIsEBChVNZXRob2REZXNjcmlwdG9yUHJvdG8SDAoEbmFt" + "ZRgBIAEoCRISCgppbnB1dF90eXBlGAIgASgJEhMKC291dHB1dF90eXBlGAMg" + "ASgJEi8KB29wdGlvbnMYBCABKAsyHi5nb29nbGUucHJvdG9idWYuTWV0aG9k" + "T3B0aW9ucxIfChBjbGllbnRfc3RyZWFtaW5nGAUgASgIOgVmYWxzZRIfChBz" + "ZXJ2ZXJfc3RyZWFtaW5nGAYgASgIOgVmYWxzZSKlBgoLRmlsZU9wdGlvbnMS" + "FAoMamF2YV9wYWNrYWdlGAEgASgJEhwKFGphdmFfb3V0ZXJfY2xhc3NuYW1l" + "GAggASgJEiIKE2phdmFfbXVsdGlwbGVfZmlsZXMYCiABKAg6BWZhbHNlEikK" + "HWphdmFfZ2VuZXJhdGVfZXF1YWxzX2FuZF9oYXNoGBQgASgIQgIYARIlChZq" + "YXZhX3N0cmluZ19jaGVja191dGY4GBsgASgIOgVmYWxzZRJGCgxvcHRpbWl6" + "ZV9mb3IYCSABKA4yKS5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMuT3B0" + "aW1pemVNb2RlOgVTUEVFRBISCgpnb19wYWNrYWdlGAsgASgJEiIKE2NjX2dl" + "bmVyaWNfc2VydmljZXMYECABKAg6BWZhbHNlEiQKFWphdmFfZ2VuZXJpY19z" + "ZXJ2aWNlcxgRIAEoCDoFZmFsc2USIgoTcHlfZ2VuZXJpY19zZXJ2aWNlcxgS" + "IAEoCDoFZmFsc2USIwoUcGhwX2dlbmVyaWNfc2VydmljZXMYKiABKAg6BWZh" + "bHNlEhkKCmRlcHJlY2F0ZWQYFyABKAg6BWZhbHNlEh4KEGNjX2VuYWJsZV9h" + "cmVuYXMYHyABKAg6BHRydWUSGQoRb2JqY19jbGFzc19wcmVmaXgYJCABKAkS" + "GAoQY3NoYXJwX25hbWVzcGFjZRglIAEoCRIUCgxzd2lmdF9wcmVmaXgYJyAB" + "KAkSGAoQcGhwX2NsYXNzX3ByZWZpeBgoIAEoCRIVCg1waHBfbmFtZXNwYWNl" + "GCkgASgJEh4KFnBocF9tZXRhZGF0YV9uYW1lc3BhY2UYLCABKAkSFAoMcnVi" + "eV9wYWNrYWdlGC0gASgJEkMKFHVuaW50ZXJwcmV0ZWRfb3B0aW9uGOcHIAMo" + "CzIkLmdvb2dsZS5wcm90b2J1Zi5VbmludGVycHJldGVkT3B0aW9uIjoKDE9w" + "dGltaXplTW9kZRIJCgVTUEVFRBABEg0KCUNPREVfU0laRRACEhAKDExJVEVf" + "UlVOVElNRRADKgkI6AcQgICAgAJKBAgmECcihAIKDk1lc3NhZ2VPcHRpb25z" + "EiYKF21lc3NhZ2Vfc2V0X3dpcmVfZm9ybWF0GAEgASgIOgVmYWxzZRIuCh9u" + "b19zdGFuZGFyZF9kZXNjcmlwdG9yX2FjY2Vzc29yGAIgASgIOgVmYWxzZRIZ" + "CgpkZXByZWNhdGVkGAMgASgIOgVmYWxzZRIRCgltYXBfZW50cnkYByABKAgS" + "QwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3Rv" + "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAkoECAQQBUoECAUQ" + "BkoECAYQB0oECAgQCUoECAkQCiK+AwoMRmllbGRPcHRpb25zEjoKBWN0eXBl" + "GAEgASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZToG" + "U1RSSU5HEg4KBnBhY2tlZBgCIAEoCBI/CgZqc3R5cGUYBiABKA4yJC5nb29n" + "bGUucHJvdG9idWYuRmllbGRPcHRpb25zLkpTVHlwZToJSlNfTk9STUFMEhMK" + "BGxhenkYBSABKAg6BWZhbHNlEh4KD3VudmVyaWZpZWRfbGF6eRgPIAEoCDoF" + "ZmFsc2USGQoKZGVwcmVjYXRlZBgDIAEoCDoFZmFsc2USEwoEd2VhaxgKIAEo" + "CDoFZmFsc2USQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29v" + "Z2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24iLwoFQ1R5cGUSCgoG" + "U1RSSU5HEAASCAoEQ09SRBABEhAKDFNUUklOR19QSUVDRRACIjUKBkpTVHlw" + "ZRINCglKU19OT1JNQUwQABINCglKU19TVFJJTkcQARINCglKU19OVU1CRVIQ" + "AioJCOgHEICAgIACSgQIBBAFIl4KDE9uZW9mT3B0aW9ucxJDChR1bmludGVy" + "cHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRl" + "cnByZXRlZE9wdGlvbioJCOgHEICAgIACIpMBCgtFbnVtT3B0aW9ucxITCgth" + "bGxvd19hbGlhcxgCIAEoCBIZCgpkZXByZWNhdGVkGAMgASgIOgVmYWxzZRJD" + "ChR1bmludGVycHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9i" + "dWYuVW5pbnRlcnByZXRlZE9wdGlvbioJCOgHEICAgIACSgQIBRAGIn0KEEVu" + "dW1WYWx1ZU9wdGlvbnMSGQoKZGVwcmVjYXRlZBgBIAEoCDoFZmFsc2USQwoU" + "dW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVm" + "LlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiJ7Cg5TZXJ2aWNlT3B0" + "aW9ucxIZCgpkZXByZWNhdGVkGCEgASgIOgVmYWxzZRJDChR1bmludGVycHJl" + "dGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnBy" + "ZXRlZE9wdGlvbioJCOgHEICAgIACIq0CCg1NZXRob2RPcHRpb25zEhkKCmRl" + "cHJlY2F0ZWQYISABKAg6BWZhbHNlEl8KEWlkZW1wb3RlbmN5X2xldmVsGCIg" + "ASgOMi8uZ29vZ2xlLnByb3RvYnVmLk1ldGhvZE9wdGlvbnMuSWRlbXBvdGVu" + "Y3lMZXZlbDoTSURFTVBPVEVOQ1lfVU5LTk9XThJDChR1bmludGVycHJldGVk" + "X29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRl" + "ZE9wdGlvbiJQChBJZGVtcG90ZW5jeUxldmVsEhcKE0lERU1QT1RFTkNZX1VO" + "S05PV04QABITCg9OT19TSURFX0VGRkVDVFMQARIOCgpJREVNUE9URU5UEAIq" + "CQjoBxCAgICAAiKeAgoTVW5pbnRlcnByZXRlZE9wdGlvbhI7CgRuYW1lGAIg" + "AygLMi0uZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24uTmFt" + "ZVBhcnQSGAoQaWRlbnRpZmllcl92YWx1ZRgDIAEoCRIaChJwb3NpdGl2ZV9p" + "bnRfdmFsdWUYBCABKAQSGgoSbmVnYXRpdmVfaW50X3ZhbHVlGAUgASgDEhQK" + "DGRvdWJsZV92YWx1ZRgGIAEoARIUCgxzdHJpbmdfdmFsdWUYByABKAwSFwoP" + "YWdncmVnYXRlX3ZhbHVlGAggASgJGjMKCE5hbWVQYXJ0EhEKCW5hbWVfcGFy" + "dBgBIAIoCRIUCgxpc19leHRlbnNpb24YAiACKAgi1QEKDlNvdXJjZUNvZGVJ" + "bmZvEjoKCGxvY2F0aW9uGAEgAygLMiguZ29vZ2xlLnByb3RvYnVmLlNvdXJj" + "ZUNvZGVJbmZvLkxvY2F0aW9uGoYBCghMb2NhdGlvbhIQCgRwYXRoGAEgAygF" + "QgIQARIQCgRzcGFuGAIgAygFQgIQARIYChBsZWFkaW5nX2NvbW1lbnRzGAMg" + "ASgJEhkKEXRyYWlsaW5nX2NvbW1lbnRzGAQgASgJEiEKGWxlYWRpbmdfZGV0" + "YWNoZWRfY29tbWVudHMYBiADKAkipwEKEUdlbmVyYXRlZENvZGVJbmZvEkEK" + "CmFubm90YXRpb24YASADKAsyLS5nb29nbGUucHJvdG9idWYuR2VuZXJhdGVk" + "Q29kZUluZm8uQW5ub3RhdGlvbhpPCgpBbm5vdGF0aW9uEhAKBHBhdGgYASAD" + "KAVCAhABEhMKC3NvdXJjZV9maWxlGAIgASgJEg0KBWJlZ2luGAMgASgFEgsK" + "A2VuZBgEIAEoBUJ+ChNjb20uZ29vZ2xlLnByb3RvYnVmQhBEZXNjcmlwdG9y" + "UHJvdG9zSAFaLWdvb2dsZS5nb2xhbmcub3JnL3Byb3RvYnVmL3R5cGVzL2Rl" + "c2NyaXB0b3JwYvgBAaICA0dQQqoCGkdvb2dsZS5Qcm90b2J1Zi5SZWZsZWN0" + "aW9u"), new FileDescriptor[0], new GeneratedClrTypeInfo(null, null, new GeneratedClrTypeInfo[21]
			{
				new GeneratedClrTypeInfo(typeof(FileDescriptorSet), FileDescriptorSet.Parser, new string[1] { "File" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(FileDescriptorProto), FileDescriptorProto.Parser, new string[12]
				{
					"Name", "Package", "Dependency", "PublicDependency", "WeakDependency", "MessageType", "EnumType", "Service", "Extension", "Options",
					"SourceCodeInfo", "Syntax"
				}, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(DescriptorProto), DescriptorProto.Parser, new string[10] { "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "OneofDecl", "Options", "ReservedRange", "ReservedName" }, null, null, null, new GeneratedClrTypeInfo[2]
				{
					new GeneratedClrTypeInfo(typeof(DescriptorProto.Types.ExtensionRange), DescriptorProto.Types.ExtensionRange.Parser, new string[3] { "Start", "End", "Options" }, null, null, null, null),
					new GeneratedClrTypeInfo(typeof(DescriptorProto.Types.ReservedRange), DescriptorProto.Types.ReservedRange.Parser, new string[2] { "Start", "End" }, null, null, null, null)
				}),
				new GeneratedClrTypeInfo(typeof(ExtensionRangeOptions), ExtensionRangeOptions.Parser, new string[1] { "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(FieldDescriptorProto), FieldDescriptorProto.Parser, new string[11]
				{
					"Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "OneofIndex", "JsonName", "Options",
					"Proto3Optional"
				}, null, new System.Type[2]
				{
					typeof(FieldDescriptorProto.Types.Type),
					typeof(FieldDescriptorProto.Types.Label)
				}, null, null),
				new GeneratedClrTypeInfo(typeof(OneofDescriptorProto), OneofDescriptorProto.Parser, new string[2] { "Name", "Options" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(EnumDescriptorProto), EnumDescriptorProto.Parser, new string[5] { "Name", "Value", "Options", "ReservedRange", "ReservedName" }, null, null, null, new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(EnumDescriptorProto.Types.EnumReservedRange), EnumDescriptorProto.Types.EnumReservedRange.Parser, new string[2] { "Start", "End" }, null, null, null, null)
				}),
				new GeneratedClrTypeInfo(typeof(EnumValueDescriptorProto), EnumValueDescriptorProto.Parser, new string[3] { "Name", "Number", "Options" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(ServiceDescriptorProto), ServiceDescriptorProto.Parser, new string[3] { "Name", "Method", "Options" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(MethodDescriptorProto), MethodDescriptorProto.Parser, new string[6] { "Name", "InputType", "OutputType", "Options", "ClientStreaming", "ServerStreaming" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(FileOptions), FileOptions.Parser, new string[21]
				{
					"JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "JavaGenerateEqualsAndHash", "JavaStringCheckUtf8", "OptimizeFor", "GoPackage", "CcGenericServices", "JavaGenericServices", "PyGenericServices",
					"PhpGenericServices", "Deprecated", "CcEnableArenas", "ObjcClassPrefix", "CsharpNamespace", "SwiftPrefix", "PhpClassPrefix", "PhpNamespace", "PhpMetadataNamespace", "RubyPackage",
					"UninterpretedOption"
				}, null, new System.Type[1] { typeof(FileOptions.Types.OptimizeMode) }, null, null),
				new GeneratedClrTypeInfo(typeof(MessageOptions), MessageOptions.Parser, new string[5] { "MessageSetWireFormat", "NoStandardDescriptorAccessor", "Deprecated", "MapEntry", "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(FieldOptions), FieldOptions.Parser, new string[8] { "Ctype", "Packed", "Jstype", "Lazy", "UnverifiedLazy", "Deprecated", "Weak", "UninterpretedOption" }, null, new System.Type[2]
				{
					typeof(FieldOptions.Types.CType),
					typeof(FieldOptions.Types.JSType)
				}, null, null),
				new GeneratedClrTypeInfo(typeof(OneofOptions), OneofOptions.Parser, new string[1] { "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(EnumOptions), EnumOptions.Parser, new string[3] { "AllowAlias", "Deprecated", "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(EnumValueOptions), EnumValueOptions.Parser, new string[2] { "Deprecated", "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(ServiceOptions), ServiceOptions.Parser, new string[2] { "Deprecated", "UninterpretedOption" }, null, null, null, null),
				new GeneratedClrTypeInfo(typeof(MethodOptions), MethodOptions.Parser, new string[3] { "Deprecated", "IdempotencyLevel", "UninterpretedOption" }, null, new System.Type[1] { typeof(MethodOptions.Types.IdempotencyLevel) }, null, null),
				new GeneratedClrTypeInfo(typeof(UninterpretedOption), UninterpretedOption.Parser, new string[7] { "Name", "IdentifierValue", "PositiveIntValue", "NegativeIntValue", "DoubleValue", "StringValue", "AggregateValue" }, null, null, null, new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(UninterpretedOption.Types.NamePart), UninterpretedOption.Types.NamePart.Parser, new string[2] { "NamePart_", "IsExtension" }, null, null, null, null)
				}),
				new GeneratedClrTypeInfo(typeof(SourceCodeInfo), SourceCodeInfo.Parser, new string[1] { "Location" }, null, null, null, new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(SourceCodeInfo.Types.Location), SourceCodeInfo.Types.Location.Parser, new string[5] { "Path", "Span", "LeadingComments", "TrailingComments", "LeadingDetachedComments" }, null, null, null, null)
				}),
				new GeneratedClrTypeInfo(typeof(GeneratedCodeInfo), GeneratedCodeInfo.Parser, new string[1] { "Annotation" }, null, null, null, new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(GeneratedCodeInfo.Types.Annotation), GeneratedCodeInfo.Types.Annotation.Parser, new string[4] { "Path", "SourceFile", "Begin", "End" }, null, null, null, null)
				})
			}));
		}
	}
	public sealed class FileDescriptorSet : IMessage<FileDescriptorSet>, IMessage, IEquatable<FileDescriptorSet>, IDeepCloneable<FileDescriptorSet>, IBufferMessage
	{
		private static readonly MessageParser<FileDescriptorSet> _parser = new MessageParser<FileDescriptorSet>(() => new FileDescriptorSet());

		private UnknownFieldSet _unknownFields;

		public const int FileFieldNumber = 1;

		private static readonly FieldCodec<FileDescriptorProto> _repeated_file_codec = FieldCodec.ForMessage(10u, FileDescriptorProto.Parser);

		private readonly RepeatedField<FileDescriptorProto> file_ = new RepeatedField<FileDescriptorProto>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FileDescriptorSet> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<FileDescriptorProto> File => file_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorSet()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorSet(FileDescriptorSet other)
			: this()
		{
			file_ = other.file_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorSet Clone()
		{
			return new FileDescriptorSet(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FileDescriptorSet);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FileDescriptorSet other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!file_.Equals(other.file_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= file_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			file_.WriteTo(ref output, _repeated_file_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += file_.CalculateSize(_repeated_file_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FileDescriptorSet other)
		{
			if (other != null)
			{
				file_.Add(other.file_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					file_.AddEntriesFrom(ref input, _repeated_file_codec);
				}
			}
		}
	}
	public sealed class FileDescriptorProto : IMessage<FileDescriptorProto>, IMessage, IEquatable<FileDescriptorProto>, IDeepCloneable<FileDescriptorProto>, IBufferMessage
	{
		private static readonly MessageParser<FileDescriptorProto> _parser = new MessageParser<FileDescriptorProto>(() => new FileDescriptorProto());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int PackageFieldNumber = 2;

		private static readonly string PackageDefaultValue = "";

		private string package_;

		public const int DependencyFieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_dependency_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> dependency_ = new RepeatedField<string>();

		public const int PublicDependencyFieldNumber = 10;

		private static readonly FieldCodec<int> _repeated_publicDependency_codec = FieldCodec.ForInt32(80u);

		private readonly RepeatedField<int> publicDependency_ = new RepeatedField<int>();

		public const int WeakDependencyFieldNumber = 11;

		private static readonly FieldCodec<int> _repeated_weakDependency_codec = FieldCodec.ForInt32(88u);

		private readonly RepeatedField<int> weakDependency_ = new RepeatedField<int>();

		public const int MessageTypeFieldNumber = 4;

		private static readonly FieldCodec<DescriptorProto> _repeated_messageType_codec = FieldCodec.ForMessage(34u, DescriptorProto.Parser);

		private readonly RepeatedField<DescriptorProto> messageType_ = new RepeatedField<DescriptorProto>();

		public const int EnumTypeFieldNumber = 5;

		private static readonly FieldCodec<EnumDescriptorProto> _repeated_enumType_codec = FieldCodec.ForMessage(42u, EnumDescriptorProto.Parser);

		private readonly RepeatedField<EnumDescriptorProto> enumType_ = new RepeatedField<EnumDescriptorProto>();

		public const int ServiceFieldNumber = 6;

		private static readonly FieldCodec<ServiceDescriptorProto> _repeated_service_codec = FieldCodec.ForMessage(50u, ServiceDescriptorProto.Parser);

		private readonly RepeatedField<ServiceDescriptorProto> service_ = new RepeatedField<ServiceDescriptorProto>();

		public const int ExtensionFieldNumber = 7;

		private static readonly FieldCodec<FieldDescriptorProto> _repeated_extension_codec = FieldCodec.ForMessage(58u, FieldDescriptorProto.Parser);

		private readonly RepeatedField<FieldDescriptorProto> extension_ = new RepeatedField<FieldDescriptorProto>();

		public const int OptionsFieldNumber = 8;

		private FileOptions options_;

		public const int SourceCodeInfoFieldNumber = 9;

		private SourceCodeInfo sourceCodeInfo_;

		public const int SyntaxFieldNumber = 12;

		private static readonly string SyntaxDefaultValue = "";

		private string syntax_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FileDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Package
		{
			get
			{
				return package_ ?? PackageDefaultValue;
			}
			set
			{
				package_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPackage => package_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<string> Dependency => dependency_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<int> PublicDependency => publicDependency_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<int> WeakDependency => weakDependency_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<DescriptorProto> MessageType => messageType_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<EnumDescriptorProto> EnumType => enumType_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<ServiceDescriptorProto> Service => service_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<FieldDescriptorProto> Extension => extension_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceCodeInfo SourceCodeInfo
		{
			get
			{
				return sourceCodeInfo_;
			}
			set
			{
				sourceCodeInfo_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Syntax
		{
			get
			{
				return syntax_ ?? SyntaxDefaultValue;
			}
			set
			{
				syntax_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasSyntax => syntax_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorProto(FileDescriptorProto other)
			: this()
		{
			name_ = other.name_;
			package_ = other.package_;
			dependency_ = other.dependency_.Clone();
			publicDependency_ = other.publicDependency_.Clone();
			weakDependency_ = other.weakDependency_.Clone();
			messageType_ = other.messageType_.Clone();
			enumType_ = other.enumType_.Clone();
			service_ = other.service_.Clone();
			extension_ = other.extension_.Clone();
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			sourceCodeInfo_ = ((other.sourceCodeInfo_ != null) ? other.sourceCodeInfo_.Clone() : null);
			syntax_ = other.syntax_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileDescriptorProto Clone()
		{
			return new FileDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPackage()
		{
			package_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearSyntax()
		{
			syntax_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FileDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FileDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Package != other.Package)
			{
				return false;
			}
			if (!dependency_.Equals(other.dependency_))
			{
				return false;
			}
			if (!publicDependency_.Equals(other.publicDependency_))
			{
				return false;
			}
			if (!weakDependency_.Equals(other.weakDependency_))
			{
				return false;
			}
			if (!messageType_.Equals(other.messageType_))
			{
				return false;
			}
			if (!enumType_.Equals(other.enumType_))
			{
				return false;
			}
			if (!service_.Equals(other.service_))
			{
				return false;
			}
			if (!extension_.Equals(other.extension_))
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			if (!object.Equals(SourceCodeInfo, other.SourceCodeInfo))
			{
				return false;
			}
			if (Syntax != other.Syntax)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			if (HasPackage)
			{
				num ^= Package.GetHashCode();
			}
			num ^= dependency_.GetHashCode();
			num ^= publicDependency_.GetHashCode();
			num ^= weakDependency_.GetHashCode();
			num ^= messageType_.GetHashCode();
			num ^= enumType_.GetHashCode();
			num ^= service_.GetHashCode();
			num ^= extension_.GetHashCode();
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (sourceCodeInfo_ != null)
			{
				num ^= SourceCodeInfo.GetHashCode();
			}
			if (HasSyntax)
			{
				num ^= Syntax.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (HasPackage)
			{
				output.WriteRawTag(18);
				output.WriteString(Package);
			}
			dependency_.WriteTo(ref output, _repeated_dependency_codec);
			messageType_.WriteTo(ref output, _repeated_messageType_codec);
			enumType_.WriteTo(ref output, _repeated_enumType_codec);
			service_.WriteTo(ref output, _repeated_service_codec);
			extension_.WriteTo(ref output, _repeated_extension_codec);
			if (options_ != null)
			{
				output.WriteRawTag(66);
				output.WriteMessage(Options);
			}
			if (sourceCodeInfo_ != null)
			{
				output.WriteRawTag(74);
				output.WriteMessage(SourceCodeInfo);
			}
			publicDependency_.WriteTo(ref output, _repeated_publicDependency_codec);
			weakDependency_.WriteTo(ref output, _repeated_weakDependency_codec);
			if (HasSyntax)
			{
				output.WriteRawTag(98);
				output.WriteString(Syntax);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (HasPackage)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Package);
			}
			num += dependency_.CalculateSize(_repeated_dependency_codec);
			num += publicDependency_.CalculateSize(_repeated_publicDependency_codec);
			num += weakDependency_.CalculateSize(_repeated_weakDependency_codec);
			num += messageType_.CalculateSize(_repeated_messageType_codec);
			num += enumType_.CalculateSize(_repeated_enumType_codec);
			num += service_.CalculateSize(_repeated_service_codec);
			num += extension_.CalculateSize(_repeated_extension_codec);
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (sourceCodeInfo_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(SourceCodeInfo);
			}
			if (HasSyntax)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Syntax);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FileDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			if (other.HasPackage)
			{
				Package = other.Package;
			}
			dependency_.Add(other.dependency_);
			publicDependency_.Add(other.publicDependency_);
			weakDependency_.Add(other.weakDependency_);
			messageType_.Add(other.messageType_);
			enumType_.Add(other.enumType_);
			service_.Add(other.service_);
			extension_.Add(other.extension_);
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new FileOptions();
				}
				Options.MergeFrom(other.Options);
			}
			if (other.sourceCodeInfo_ != null)
			{
				if (sourceCodeInfo_ == null)
				{
					SourceCodeInfo = new SourceCodeInfo();
				}
				SourceCodeInfo.MergeFrom(other.SourceCodeInfo);
			}
			if (other.HasSyntax)
			{
				Syntax = other.Syntax;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					Package = input.ReadString();
					break;
				case 26u:
					dependency_.AddEntriesFrom(ref input, _repeated_dependency_codec);
					break;
				case 34u:
					messageType_.AddEntriesFrom(ref input, _repeated_messageType_codec);
					break;
				case 42u:
					enumType_.AddEntriesFrom(ref input, _repeated_enumType_codec);
					break;
				case 50u:
					service_.AddEntriesFrom(ref input, _repeated_service_codec);
					break;
				case 58u:
					extension_.AddEntriesFrom(ref input, _repeated_extension_codec);
					break;
				case 66u:
					if (options_ == null)
					{
						Options = new FileOptions();
					}
					input.ReadMessage(Options);
					break;
				case 74u:
					if (sourceCodeInfo_ == null)
					{
						SourceCodeInfo = new SourceCodeInfo();
					}
					input.ReadMessage(SourceCodeInfo);
					break;
				case 80u:
				case 82u:
					publicDependency_.AddEntriesFrom(ref input, _repeated_publicDependency_codec);
					break;
				case 88u:
				case 90u:
					weakDependency_.AddEntriesFrom(ref input, _repeated_weakDependency_codec);
					break;
				case 98u:
					Syntax = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class DescriptorProto : IMessage<DescriptorProto>, IMessage, IEquatable<DescriptorProto>, IDeepCloneable<DescriptorProto>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public sealed class ExtensionRange : IMessage<ExtensionRange>, IMessage, IEquatable<ExtensionRange>, IDeepCloneable<ExtensionRange>, IBufferMessage
			{
				private static readonly MessageParser<ExtensionRange> _parser = new MessageParser<ExtensionRange>(() => new ExtensionRange());

				private UnknownFieldSet _unknownFields;

				private int _hasBits0;

				public const int StartFieldNumber = 1;

				private static readonly int StartDefaultValue = 0;

				private int start_;

				public const int EndFieldNumber = 2;

				private static readonly int EndDefaultValue = 0;

				private int end_;

				public const int OptionsFieldNumber = 3;

				private ExtensionRangeOptions options_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<ExtensionRange> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => DescriptorProto.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int Start
				{
					get
					{
						if ((_hasBits0 & 1) != 0)
						{
							return start_;
						}
						return StartDefaultValue;
					}
					set
					{
						_hasBits0 |= 1;
						start_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasStart => (_hasBits0 & 1) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int End
				{
					get
					{
						if ((_hasBits0 & 2) != 0)
						{
							return end_;
						}
						return EndDefaultValue;
					}
					set
					{
						_hasBits0 |= 2;
						end_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasEnd => (_hasBits0 & 2) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ExtensionRangeOptions Options
				{
					get
					{
						return options_;
					}
					set
					{
						options_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ExtensionRange()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ExtensionRange(ExtensionRange other)
					: this()
				{
					_hasBits0 = other._hasBits0;
					start_ = other.start_;
					end_ = other.end_;
					options_ = ((other.options_ != null) ? other.options_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ExtensionRange Clone()
				{
					return new ExtensionRange(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearStart()
				{
					_hasBits0 &= -2;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearEnd()
				{
					_hasBits0 &= -3;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as ExtensionRange);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(ExtensionRange other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Start != other.Start)
					{
						return false;
					}
					if (End != other.End)
					{
						return false;
					}
					if (!object.Equals(Options, other.Options))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					if (HasStart)
					{
						num ^= Start.GetHashCode();
					}
					if (HasEnd)
					{
						num ^= End.GetHashCode();
					}
					if (options_ != null)
					{
						num ^= Options.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					if (HasStart)
					{
						output.WriteRawTag(8);
						output.WriteInt32(Start);
					}
					if (HasEnd)
					{
						output.WriteRawTag(16);
						output.WriteInt32(End);
					}
					if (options_ != null)
					{
						output.WriteRawTag(26);
						output.WriteMessage(Options);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					if (HasStart)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Start);
					}
					if (HasEnd)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(End);
					}
					if (options_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize(Options);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(ExtensionRange other)
				{
					if (other == null)
					{
						return;
					}
					if (other.HasStart)
					{
						Start = other.Start;
					}
					if (other.HasEnd)
					{
						End = other.End;
					}
					if (other.options_ != null)
					{
						if (options_ == null)
						{
							Options = new ExtensionRangeOptions();
						}
						Options.MergeFrom(other.Options);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 8u:
							Start = input.ReadInt32();
							break;
						case 16u:
							End = input.ReadInt32();
							break;
						case 26u:
							if (options_ == null)
							{
								Options = new ExtensionRangeOptions();
							}
							input.ReadMessage(Options);
							break;
						}
					}
				}
			}

			public sealed class ReservedRange : IMessage<ReservedRange>, IMessage, IEquatable<ReservedRange>, IDeepCloneable<ReservedRange>, IBufferMessage
			{
				private static readonly MessageParser<ReservedRange> _parser = new MessageParser<ReservedRange>(() => new ReservedRange());

				private UnknownFieldSet _unknownFields;

				private int _hasBits0;

				public const int StartFieldNumber = 1;

				private static readonly int StartDefaultValue = 0;

				private int start_;

				public const int EndFieldNumber = 2;

				private static readonly int EndDefaultValue = 0;

				private int end_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<ReservedRange> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => DescriptorProto.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int Start
				{
					get
					{
						if ((_hasBits0 & 1) != 0)
						{
							return start_;
						}
						return StartDefaultValue;
					}
					set
					{
						_hasBits0 |= 1;
						start_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasStart => (_hasBits0 & 1) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int End
				{
					get
					{
						if ((_hasBits0 & 2) != 0)
						{
							return end_;
						}
						return EndDefaultValue;
					}
					set
					{
						_hasBits0 |= 2;
						end_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasEnd => (_hasBits0 & 2) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ReservedRange()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ReservedRange(ReservedRange other)
					: this()
				{
					_hasBits0 = other._hasBits0;
					start_ = other.start_;
					end_ = other.end_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public ReservedRange Clone()
				{
					return new ReservedRange(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearStart()
				{
					_hasBits0 &= -2;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearEnd()
				{
					_hasBits0 &= -3;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as ReservedRange);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(ReservedRange other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Start != other.Start)
					{
						return false;
					}
					if (End != other.End)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					if (HasStart)
					{
						num ^= Start.GetHashCode();
					}
					if (HasEnd)
					{
						num ^= End.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					if (HasStart)
					{
						output.WriteRawTag(8);
						output.WriteInt32(Start);
					}
					if (HasEnd)
					{
						output.WriteRawTag(16);
						output.WriteInt32(End);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					if (HasStart)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Start);
					}
					if (HasEnd)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(End);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(ReservedRange other)
				{
					if (other != null)
					{
						if (other.HasStart)
						{
							Start = other.Start;
						}
						if (other.HasEnd)
						{
							End = other.End;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 8u:
							Start = input.ReadInt32();
							break;
						case 16u:
							End = input.ReadInt32();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<DescriptorProto> _parser = new MessageParser<DescriptorProto>(() => new DescriptorProto());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int FieldFieldNumber = 2;

		private static readonly FieldCodec<FieldDescriptorProto> _repeated_field_codec = FieldCodec.ForMessage(18u, FieldDescriptorProto.Parser);

		private readonly RepeatedField<FieldDescriptorProto> field_ = new RepeatedField<FieldDescriptorProto>();

		public const int ExtensionFieldNumber = 6;

		private static readonly FieldCodec<FieldDescriptorProto> _repeated_extension_codec = FieldCodec.ForMessage(50u, FieldDescriptorProto.Parser);

		private readonly RepeatedField<FieldDescriptorProto> extension_ = new RepeatedField<FieldDescriptorProto>();

		public const int NestedTypeFieldNumber = 3;

		private static readonly FieldCodec<DescriptorProto> _repeated_nestedType_codec = FieldCodec.ForMessage(26u, Parser);

		private readonly RepeatedField<DescriptorProto> nestedType_ = new RepeatedField<DescriptorProto>();

		public const int EnumTypeFieldNumber = 4;

		private static readonly FieldCodec<EnumDescriptorProto> _repeated_enumType_codec = FieldCodec.ForMessage(34u, EnumDescriptorProto.Parser);

		private readonly RepeatedField<EnumDescriptorProto> enumType_ = new RepeatedField<EnumDescriptorProto>();

		public const int ExtensionRangeFieldNumber = 5;

		private static readonly FieldCodec<Types.ExtensionRange> _repeated_extensionRange_codec = FieldCodec.ForMessage(42u, Types.ExtensionRange.Parser);

		private readonly RepeatedField<Types.ExtensionRange> extensionRange_ = new RepeatedField<Types.ExtensionRange>();

		public const int OneofDeclFieldNumber = 8;

		private static readonly FieldCodec<OneofDescriptorProto> _repeated_oneofDecl_codec = FieldCodec.ForMessage(66u, OneofDescriptorProto.Parser);

		private readonly RepeatedField<OneofDescriptorProto> oneofDecl_ = new RepeatedField<OneofDescriptorProto>();

		public const int OptionsFieldNumber = 7;

		private MessageOptions options_;

		public const int ReservedRangeFieldNumber = 9;

		private static readonly FieldCodec<Types.ReservedRange> _repeated_reservedRange_codec = FieldCodec.ForMessage(74u, Types.ReservedRange.Parser);

		private readonly RepeatedField<Types.ReservedRange> reservedRange_ = new RepeatedField<Types.ReservedRange>();

		public const int ReservedNameFieldNumber = 10;

		private static readonly FieldCodec<string> _repeated_reservedName_codec = FieldCodec.ForString(82u);

		private readonly RepeatedField<string> reservedName_ = new RepeatedField<string>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<DescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<FieldDescriptorProto> Field => field_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<FieldDescriptorProto> Extension => extension_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<DescriptorProto> NestedType => nestedType_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<EnumDescriptorProto> EnumType => enumType_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.ExtensionRange> ExtensionRange => extensionRange_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<OneofDescriptorProto> OneofDecl => oneofDecl_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MessageOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.ReservedRange> ReservedRange => reservedRange_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<string> ReservedName => reservedName_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DescriptorProto(DescriptorProto other)
			: this()
		{
			name_ = other.name_;
			field_ = other.field_.Clone();
			extension_ = other.extension_.Clone();
			nestedType_ = other.nestedType_.Clone();
			enumType_ = other.enumType_.Clone();
			extensionRange_ = other.extensionRange_.Clone();
			oneofDecl_ = other.oneofDecl_.Clone();
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			reservedRange_ = other.reservedRange_.Clone();
			reservedName_ = other.reservedName_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public DescriptorProto Clone()
		{
			return new DescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as DescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(DescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!field_.Equals(other.field_))
			{
				return false;
			}
			if (!extension_.Equals(other.extension_))
			{
				return false;
			}
			if (!nestedType_.Equals(other.nestedType_))
			{
				return false;
			}
			if (!enumType_.Equals(other.enumType_))
			{
				return false;
			}
			if (!extensionRange_.Equals(other.extensionRange_))
			{
				return false;
			}
			if (!oneofDecl_.Equals(other.oneofDecl_))
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			if (!reservedRange_.Equals(other.reservedRange_))
			{
				return false;
			}
			if (!reservedName_.Equals(other.reservedName_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			num ^= field_.GetHashCode();
			num ^= extension_.GetHashCode();
			num ^= nestedType_.GetHashCode();
			num ^= enumType_.GetHashCode();
			num ^= extensionRange_.GetHashCode();
			num ^= oneofDecl_.GetHashCode();
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			num ^= reservedRange_.GetHashCode();
			num ^= reservedName_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			field_.WriteTo(ref output, _repeated_field_codec);
			nestedType_.WriteTo(ref output, _repeated_nestedType_codec);
			enumType_.WriteTo(ref output, _repeated_enumType_codec);
			extensionRange_.WriteTo(ref output, _repeated_extensionRange_codec);
			extension_.WriteTo(ref output, _repeated_extension_codec);
			if (options_ != null)
			{
				output.WriteRawTag(58);
				output.WriteMessage(Options);
			}
			oneofDecl_.WriteTo(ref output, _repeated_oneofDecl_codec);
			reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
			reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += field_.CalculateSize(_repeated_field_codec);
			num += extension_.CalculateSize(_repeated_extension_codec);
			num += nestedType_.CalculateSize(_repeated_nestedType_codec);
			num += enumType_.CalculateSize(_repeated_enumType_codec);
			num += extensionRange_.CalculateSize(_repeated_extensionRange_codec);
			num += oneofDecl_.CalculateSize(_repeated_oneofDecl_codec);
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			num += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
			num += reservedName_.CalculateSize(_repeated_reservedName_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(DescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			field_.Add(other.field_);
			extension_.Add(other.extension_);
			nestedType_.Add(other.nestedType_);
			enumType_.Add(other.enumType_);
			extensionRange_.Add(other.extensionRange_);
			oneofDecl_.Add(other.oneofDecl_);
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new MessageOptions();
				}
				Options.MergeFrom(other.Options);
			}
			reservedRange_.Add(other.reservedRange_);
			reservedName_.Add(other.reservedName_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					field_.AddEntriesFrom(ref input, _repeated_field_codec);
					break;
				case 26u:
					nestedType_.AddEntriesFrom(ref input, _repeated_nestedType_codec);
					break;
				case 34u:
					enumType_.AddEntriesFrom(ref input, _repeated_enumType_codec);
					break;
				case 42u:
					extensionRange_.AddEntriesFrom(ref input, _repeated_extensionRange_codec);
					break;
				case 50u:
					extension_.AddEntriesFrom(ref input, _repeated_extension_codec);
					break;
				case 58u:
					if (options_ == null)
					{
						Options = new MessageOptions();
					}
					input.ReadMessage(Options);
					break;
				case 66u:
					oneofDecl_.AddEntriesFrom(ref input, _repeated_oneofDecl_codec);
					break;
				case 74u:
					reservedRange_.AddEntriesFrom(ref input, _repeated_reservedRange_codec);
					break;
				case 82u:
					reservedName_.AddEntriesFrom(ref input, _repeated_reservedName_codec);
					break;
				}
			}
		}
	}
	public sealed class ExtensionRangeOptions : IExtendableMessage<ExtensionRangeOptions>, IMessage<ExtensionRangeOptions>, IMessage, IEquatable<ExtensionRangeOptions>, IDeepCloneable<ExtensionRangeOptions>, IBufferMessage
	{
		private static readonly MessageParser<ExtensionRangeOptions> _parser = new MessageParser<ExtensionRangeOptions>(() => new ExtensionRangeOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<ExtensionRangeOptions> _extensions;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<ExtensionRangeOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ExtensionRangeOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ExtensionRangeOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ExtensionRangeOptions(ExtensionRangeOptions other)
			: this()
		{
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ExtensionRangeOptions Clone()
		{
			return new ExtensionRangeOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ExtensionRangeOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ExtensionRangeOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ExtensionRangeOptions other)
		{
			if (other != null)
			{
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 7994)
				{
					if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
					{
						_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					}
				}
				else
				{
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<ExtensionRangeOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<ExtensionRangeOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<ExtensionRangeOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<ExtensionRangeOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<ExtensionRangeOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<ExtensionRangeOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<ExtensionRangeOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class FieldDescriptorProto : IMessage<FieldDescriptorProto>, IMessage, IEquatable<FieldDescriptorProto>, IDeepCloneable<FieldDescriptorProto>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public enum Type
			{
				[OriginalName("TYPE_DOUBLE")]
				Double = 1,
				[OriginalName("TYPE_FLOAT")]
				Float,
				[OriginalName("TYPE_INT64")]
				Int64,
				[OriginalName("TYPE_UINT64")]
				Uint64,
				[OriginalName("TYPE_INT32")]
				Int32,
				[OriginalName("TYPE_FIXED64")]
				Fixed64,
				[OriginalName("TYPE_FIXED32")]
				Fixed32,
				[OriginalName("TYPE_BOOL")]
				Bool,
				[OriginalName("TYPE_STRING")]
				String,
				[OriginalName("TYPE_GROUP")]
				Group,
				[OriginalName("TYPE_MESSAGE")]
				Message,
				[OriginalName("TYPE_BYTES")]
				Bytes,
				[OriginalName("TYPE_UINT32")]
				Uint32,
				[OriginalName("TYPE_ENUM")]
				Enum,
				[OriginalName("TYPE_SFIXED32")]
				Sfixed32,
				[OriginalName("TYPE_SFIXED64")]
				Sfixed64,
				[OriginalName("TYPE_SINT32")]
				Sint32,
				[OriginalName("TYPE_SINT64")]
				Sint64
			}

			public enum Label
			{
				[OriginalName("LABEL_OPTIONAL")]
				Optional = 1,
				[OriginalName("LABEL_REQUIRED")]
				Required,
				[OriginalName("LABEL_REPEATED")]
				Repeated
			}
		}

		private static readonly MessageParser<FieldDescriptorProto> _parser = new MessageParser<FieldDescriptorProto>(() => new FieldDescriptorProto());

		private UnknownFieldSet _unknownFields;

		private int _hasBits0;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int NumberFieldNumber = 3;

		private static readonly int NumberDefaultValue = 0;

		private int number_;

		public const int LabelFieldNumber = 4;

		private static readonly Types.Label LabelDefaultValue = Types.Label.Optional;

		private Types.Label label_;

		public const int TypeFieldNumber = 5;

		private static readonly Types.Type TypeDefaultValue = Types.Type.Double;

		private Types.Type type_;

		public const int TypeNameFieldNumber = 6;

		private static readonly string TypeNameDefaultValue = "";

		private string typeName_;

		public const int ExtendeeFieldNumber = 2;

		private static readonly string ExtendeeDefaultValue = "";

		private string extendee_;

		public const int DefaultValueFieldNumber = 7;

		private static readonly string DefaultValueDefaultValue = "";

		private string defaultValue_;

		public const int OneofIndexFieldNumber = 9;

		private static readonly int OneofIndexDefaultValue = 0;

		private int oneofIndex_;

		public const int JsonNameFieldNumber = 10;

		private static readonly string JsonNameDefaultValue = "";

		private string jsonName_;

		public const int OptionsFieldNumber = 8;

		private FieldOptions options_;

		public const int Proto3OptionalFieldNumber = 17;

		private static readonly bool Proto3OptionalDefaultValue = false;

		private bool proto3Optional_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FieldDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Number
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return number_;
				}
				return NumberDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				number_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasNumber => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.Label Label
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return label_;
				}
				return LabelDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				label_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasLabel => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.Type Type
		{
			get
			{
				if ((_hasBits0 & 4) != 0)
				{
					return type_;
				}
				return TypeDefaultValue;
			}
			set
			{
				_hasBits0 |= 4;
				type_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasType => (_hasBits0 & 4) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string TypeName
		{
			get
			{
				return typeName_ ?? TypeNameDefaultValue;
			}
			set
			{
				typeName_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasTypeName => typeName_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Extendee
		{
			get
			{
				return extendee_ ?? ExtendeeDefaultValue;
			}
			set
			{
				extendee_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasExtendee => extendee_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string DefaultValue
		{
			get
			{
				return defaultValue_ ?? DefaultValueDefaultValue;
			}
			set
			{
				defaultValue_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDefaultValue => defaultValue_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int OneofIndex
		{
			get
			{
				if ((_hasBits0 & 8) != 0)
				{
					return oneofIndex_;
				}
				return OneofIndexDefaultValue;
			}
			set
			{
				_hasBits0 |= 8;
				oneofIndex_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasOneofIndex => (_hasBits0 & 8) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string JsonName
		{
			get
			{
				return jsonName_ ?? JsonNameDefaultValue;
			}
			set
			{
				jsonName_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJsonName => jsonName_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Proto3Optional
		{
			get
			{
				if ((_hasBits0 & 0x10) != 0)
				{
					return proto3Optional_;
				}
				return Proto3OptionalDefaultValue;
			}
			set
			{
				_hasBits0 |= 16;
				proto3Optional_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasProto3Optional => (_hasBits0 & 0x10) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldDescriptorProto(FieldDescriptorProto other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			name_ = other.name_;
			number_ = other.number_;
			label_ = other.label_;
			type_ = other.type_;
			typeName_ = other.typeName_;
			extendee_ = other.extendee_;
			defaultValue_ = other.defaultValue_;
			oneofIndex_ = other.oneofIndex_;
			jsonName_ = other.jsonName_;
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			proto3Optional_ = other.proto3Optional_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldDescriptorProto Clone()
		{
			return new FieldDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearNumber()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearLabel()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearType()
		{
			_hasBits0 &= -5;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearTypeName()
		{
			typeName_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearExtendee()
		{
			extendee_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDefaultValue()
		{
			defaultValue_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearOneofIndex()
		{
			_hasBits0 &= -9;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJsonName()
		{
			jsonName_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearProto3Optional()
		{
			_hasBits0 &= -17;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FieldDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FieldDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Number != other.Number)
			{
				return false;
			}
			if (Label != other.Label)
			{
				return false;
			}
			if (Type != other.Type)
			{
				return false;
			}
			if (TypeName != other.TypeName)
			{
				return false;
			}
			if (Extendee != other.Extendee)
			{
				return false;
			}
			if (DefaultValue != other.DefaultValue)
			{
				return false;
			}
			if (OneofIndex != other.OneofIndex)
			{
				return false;
			}
			if (JsonName != other.JsonName)
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			if (Proto3Optional != other.Proto3Optional)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			if (HasNumber)
			{
				num ^= Number.GetHashCode();
			}
			if (HasLabel)
			{
				num ^= Label.GetHashCode();
			}
			if (HasType)
			{
				num ^= Type.GetHashCode();
			}
			if (HasTypeName)
			{
				num ^= TypeName.GetHashCode();
			}
			if (HasExtendee)
			{
				num ^= Extendee.GetHashCode();
			}
			if (HasDefaultValue)
			{
				num ^= DefaultValue.GetHashCode();
			}
			if (HasOneofIndex)
			{
				num ^= OneofIndex.GetHashCode();
			}
			if (HasJsonName)
			{
				num ^= JsonName.GetHashCode();
			}
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (HasProto3Optional)
			{
				num ^= Proto3Optional.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (HasExtendee)
			{
				output.WriteRawTag(18);
				output.WriteString(Extendee);
			}
			if (HasNumber)
			{
				output.WriteRawTag(24);
				output.WriteInt32(Number);
			}
			if (HasLabel)
			{
				output.WriteRawTag(32);
				output.WriteEnum((int)Label);
			}
			if (HasType)
			{
				output.WriteRawTag(40);
				output.WriteEnum((int)Type);
			}
			if (HasTypeName)
			{
				output.WriteRawTag(50);
				output.WriteString(TypeName);
			}
			if (HasDefaultValue)
			{
				output.WriteRawTag(58);
				output.WriteString(DefaultValue);
			}
			if (options_ != null)
			{
				output.WriteRawTag(66);
				output.WriteMessage(Options);
			}
			if (HasOneofIndex)
			{
				output.WriteRawTag(72);
				output.WriteInt32(OneofIndex);
			}
			if (HasJsonName)
			{
				output.WriteRawTag(82);
				output.WriteString(JsonName);
			}
			if (HasProto3Optional)
			{
				output.WriteRawTag(136, 1);
				output.WriteBool(Proto3Optional);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (HasNumber)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Number);
			}
			if (HasLabel)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Label);
			}
			if (HasType)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Type);
			}
			if (HasTypeName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeName);
			}
			if (HasExtendee)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Extendee);
			}
			if (HasDefaultValue)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DefaultValue);
			}
			if (HasOneofIndex)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(OneofIndex);
			}
			if (HasJsonName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(JsonName);
			}
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (HasProto3Optional)
			{
				num += 3;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FieldDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			if (other.HasNumber)
			{
				Number = other.Number;
			}
			if (other.HasLabel)
			{
				Label = other.Label;
			}
			if (other.HasType)
			{
				Type = other.Type;
			}
			if (other.HasTypeName)
			{
				TypeName = other.TypeName;
			}
			if (other.HasExtendee)
			{
				Extendee = other.Extendee;
			}
			if (other.HasDefaultValue)
			{
				DefaultValue = other.DefaultValue;
			}
			if (other.HasOneofIndex)
			{
				OneofIndex = other.OneofIndex;
			}
			if (other.HasJsonName)
			{
				JsonName = other.JsonName;
			}
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new FieldOptions();
				}
				Options.MergeFrom(other.Options);
			}
			if (other.HasProto3Optional)
			{
				Proto3Optional = other.Proto3Optional;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					Extendee = input.ReadString();
					break;
				case 24u:
					Number = input.ReadInt32();
					break;
				case 32u:
					Label = (Types.Label)input.ReadEnum();
					break;
				case 40u:
					Type = (Types.Type)input.ReadEnum();
					break;
				case 50u:
					TypeName = input.ReadString();
					break;
				case 58u:
					DefaultValue = input.ReadString();
					break;
				case 66u:
					if (options_ == null)
					{
						Options = new FieldOptions();
					}
					input.ReadMessage(Options);
					break;
				case 72u:
					OneofIndex = input.ReadInt32();
					break;
				case 82u:
					JsonName = input.ReadString();
					break;
				case 136u:
					Proto3Optional = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class OneofDescriptorProto : IMessage<OneofDescriptorProto>, IMessage, IEquatable<OneofDescriptorProto>, IDeepCloneable<OneofDescriptorProto>, IBufferMessage
	{
		private static readonly MessageParser<OneofDescriptorProto> _parser = new MessageParser<OneofDescriptorProto>(() => new OneofDescriptorProto());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int OptionsFieldNumber = 2;

		private OneofOptions options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<OneofDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofDescriptorProto(OneofDescriptorProto other)
			: this()
		{
			name_ = other.name_;
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofDescriptorProto Clone()
		{
			return new OneofDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as OneofDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(OneofDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (options_ != null)
			{
				output.WriteRawTag(18);
				output.WriteMessage(Options);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(OneofDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new OneofOptions();
				}
				Options.MergeFrom(other.Options);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					if (options_ == null)
					{
						Options = new OneofOptions();
					}
					input.ReadMessage(Options);
					break;
				}
			}
		}
	}
	public sealed class EnumDescriptorProto : IMessage<EnumDescriptorProto>, IMessage, IEquatable<EnumDescriptorProto>, IDeepCloneable<EnumDescriptorProto>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public sealed class EnumReservedRange : IMessage<EnumReservedRange>, IMessage, IEquatable<EnumReservedRange>, IDeepCloneable<EnumReservedRange>, IBufferMessage
			{
				private static readonly MessageParser<EnumReservedRange> _parser = new MessageParser<EnumReservedRange>(() => new EnumReservedRange());

				private UnknownFieldSet _unknownFields;

				private int _hasBits0;

				public const int StartFieldNumber = 1;

				private static readonly int StartDefaultValue = 0;

				private int start_;

				public const int EndFieldNumber = 2;

				private static readonly int EndDefaultValue = 0;

				private int end_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<EnumReservedRange> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => EnumDescriptorProto.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int Start
				{
					get
					{
						if ((_hasBits0 & 1) != 0)
						{
							return start_;
						}
						return StartDefaultValue;
					}
					set
					{
						_hasBits0 |= 1;
						start_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasStart => (_hasBits0 & 1) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int End
				{
					get
					{
						if ((_hasBits0 & 2) != 0)
						{
							return end_;
						}
						return EndDefaultValue;
					}
					set
					{
						_hasBits0 |= 2;
						end_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasEnd => (_hasBits0 & 2) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public EnumReservedRange()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public EnumReservedRange(EnumReservedRange other)
					: this()
				{
					_hasBits0 = other._hasBits0;
					start_ = other.start_;
					end_ = other.end_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public EnumReservedRange Clone()
				{
					return new EnumReservedRange(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearStart()
				{
					_hasBits0 &= -2;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearEnd()
				{
					_hasBits0 &= -3;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as EnumReservedRange);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(EnumReservedRange other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Start != other.Start)
					{
						return false;
					}
					if (End != other.End)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					if (HasStart)
					{
						num ^= Start.GetHashCode();
					}
					if (HasEnd)
					{
						num ^= End.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					if (HasStart)
					{
						output.WriteRawTag(8);
						output.WriteInt32(Start);
					}
					if (HasEnd)
					{
						output.WriteRawTag(16);
						output.WriteInt32(End);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					if (HasStart)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Start);
					}
					if (HasEnd)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(End);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(EnumReservedRange other)
				{
					if (other != null)
					{
						if (other.HasStart)
						{
							Start = other.Start;
						}
						if (other.HasEnd)
						{
							End = other.End;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 8u:
							Start = input.ReadInt32();
							break;
						case 16u:
							End = input.ReadInt32();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<EnumDescriptorProto> _parser = new MessageParser<EnumDescriptorProto>(() => new EnumDescriptorProto());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int ValueFieldNumber = 2;

		private static readonly FieldCodec<EnumValueDescriptorProto> _repeated_value_codec = FieldCodec.ForMessage(18u, EnumValueDescriptorProto.Parser);

		private readonly RepeatedField<EnumValueDescriptorProto> value_ = new RepeatedField<EnumValueDescriptorProto>();

		public const int OptionsFieldNumber = 3;

		private EnumOptions options_;

		public const int ReservedRangeFieldNumber = 4;

		private static readonly FieldCodec<Types.EnumReservedRange> _repeated_reservedRange_codec = FieldCodec.ForMessage(34u, Types.EnumReservedRange.Parser);

		private readonly RepeatedField<Types.EnumReservedRange> reservedRange_ = new RepeatedField<Types.EnumReservedRange>();

		public const int ReservedNameFieldNumber = 5;

		private static readonly FieldCodec<string> _repeated_reservedName_codec = FieldCodec.ForString(42u);

		private readonly RepeatedField<string> reservedName_ = new RepeatedField<string>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<EnumDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<EnumValueDescriptorProto> Value => value_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.EnumReservedRange> ReservedRange => reservedRange_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<string> ReservedName => reservedName_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumDescriptorProto(EnumDescriptorProto other)
			: this()
		{
			name_ = other.name_;
			value_ = other.value_.Clone();
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			reservedRange_ = other.reservedRange_.Clone();
			reservedName_ = other.reservedName_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumDescriptorProto Clone()
		{
			return new EnumDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as EnumDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(EnumDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!value_.Equals(other.value_))
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			if (!reservedRange_.Equals(other.reservedRange_))
			{
				return false;
			}
			if (!reservedName_.Equals(other.reservedName_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			num ^= value_.GetHashCode();
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			num ^= reservedRange_.GetHashCode();
			num ^= reservedName_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			value_.WriteTo(ref output, _repeated_value_codec);
			if (options_ != null)
			{
				output.WriteRawTag(26);
				output.WriteMessage(Options);
			}
			reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
			reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += value_.CalculateSize(_repeated_value_codec);
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			num += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
			num += reservedName_.CalculateSize(_repeated_reservedName_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(EnumDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			value_.Add(other.value_);
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new EnumOptions();
				}
				Options.MergeFrom(other.Options);
			}
			reservedRange_.Add(other.reservedRange_);
			reservedName_.Add(other.reservedName_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					value_.AddEntriesFrom(ref input, _repeated_value_codec);
					break;
				case 26u:
					if (options_ == null)
					{
						Options = new EnumOptions();
					}
					input.ReadMessage(Options);
					break;
				case 34u:
					reservedRange_.AddEntriesFrom(ref input, _repeated_reservedRange_codec);
					break;
				case 42u:
					reservedName_.AddEntriesFrom(ref input, _repeated_reservedName_codec);
					break;
				}
			}
		}
	}
	public sealed class EnumValueDescriptorProto : IMessage<EnumValueDescriptorProto>, IMessage, IEquatable<EnumValueDescriptorProto>, IDeepCloneable<EnumValueDescriptorProto>, IBufferMessage
	{
		private static readonly MessageParser<EnumValueDescriptorProto> _parser = new MessageParser<EnumValueDescriptorProto>(() => new EnumValueDescriptorProto());

		private UnknownFieldSet _unknownFields;

		private int _hasBits0;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int NumberFieldNumber = 2;

		private static readonly int NumberDefaultValue = 0;

		private int number_;

		public const int OptionsFieldNumber = 3;

		private EnumValueOptions options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<EnumValueDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int Number
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return number_;
				}
				return NumberDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				number_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasNumber => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueDescriptorProto(EnumValueDescriptorProto other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			name_ = other.name_;
			number_ = other.number_;
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueDescriptorProto Clone()
		{
			return new EnumValueDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearNumber()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as EnumValueDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(EnumValueDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Number != other.Number)
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			if (HasNumber)
			{
				num ^= Number.GetHashCode();
			}
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (HasNumber)
			{
				output.WriteRawTag(16);
				output.WriteInt32(Number);
			}
			if (options_ != null)
			{
				output.WriteRawTag(26);
				output.WriteMessage(Options);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (HasNumber)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Number);
			}
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(EnumValueDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			if (other.HasNumber)
			{
				Number = other.Number;
			}
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new EnumValueOptions();
				}
				Options.MergeFrom(other.Options);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 16u:
					Number = input.ReadInt32();
					break;
				case 26u:
					if (options_ == null)
					{
						Options = new EnumValueOptions();
					}
					input.ReadMessage(Options);
					break;
				}
			}
		}
	}
	public sealed class ServiceDescriptorProto : IMessage<ServiceDescriptorProto>, IMessage, IEquatable<ServiceDescriptorProto>, IDeepCloneable<ServiceDescriptorProto>, IBufferMessage
	{
		private static readonly MessageParser<ServiceDescriptorProto> _parser = new MessageParser<ServiceDescriptorProto>(() => new ServiceDescriptorProto());

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int MethodFieldNumber = 2;

		private static readonly FieldCodec<MethodDescriptorProto> _repeated_method_codec = FieldCodec.ForMessage(18u, MethodDescriptorProto.Parser);

		private readonly RepeatedField<MethodDescriptorProto> method_ = new RepeatedField<MethodDescriptorProto>();

		public const int OptionsFieldNumber = 3;

		private ServiceOptions options_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ServiceDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<MethodDescriptorProto> Method => method_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceDescriptorProto(ServiceDescriptorProto other)
			: this()
		{
			name_ = other.name_;
			method_ = other.method_.Clone();
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceDescriptorProto Clone()
		{
			return new ServiceDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ServiceDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ServiceDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!method_.Equals(other.method_))
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			num ^= method_.GetHashCode();
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			method_.WriteTo(ref output, _repeated_method_codec);
			if (options_ != null)
			{
				output.WriteRawTag(26);
				output.WriteMessage(Options);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += method_.CalculateSize(_repeated_method_codec);
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ServiceDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			method_.Add(other.method_);
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new ServiceOptions();
				}
				Options.MergeFrom(other.Options);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					method_.AddEntriesFrom(ref input, _repeated_method_codec);
					break;
				case 26u:
					if (options_ == null)
					{
						Options = new ServiceOptions();
					}
					input.ReadMessage(Options);
					break;
				}
			}
		}
	}
	public sealed class MethodDescriptorProto : IMessage<MethodDescriptorProto>, IMessage, IEquatable<MethodDescriptorProto>, IDeepCloneable<MethodDescriptorProto>, IBufferMessage
	{
		private static readonly MessageParser<MethodDescriptorProto> _parser = new MessageParser<MethodDescriptorProto>(() => new MethodDescriptorProto());

		private UnknownFieldSet _unknownFields;

		private int _hasBits0;

		public const int NameFieldNumber = 1;

		private static readonly string NameDefaultValue = "";

		private string name_;

		public const int InputTypeFieldNumber = 2;

		private static readonly string InputTypeDefaultValue = "";

		private string inputType_;

		public const int OutputTypeFieldNumber = 3;

		private static readonly string OutputTypeDefaultValue = "";

		private string outputType_;

		public const int OptionsFieldNumber = 4;

		private MethodOptions options_;

		public const int ClientStreamingFieldNumber = 5;

		private static readonly bool ClientStreamingDefaultValue = false;

		private bool clientStreaming_;

		public const int ServerStreamingFieldNumber = 6;

		private static readonly bool ServerStreamingDefaultValue = false;

		private bool serverStreaming_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<MethodDescriptorProto> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string Name
		{
			get
			{
				return name_ ?? NameDefaultValue;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasName => name_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string InputType
		{
			get
			{
				return inputType_ ?? InputTypeDefaultValue;
			}
			set
			{
				inputType_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasInputType => inputType_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string OutputType
		{
			get
			{
				return outputType_ ?? OutputTypeDefaultValue;
			}
			set
			{
				outputType_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasOutputType => outputType_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodOptions Options
		{
			get
			{
				return options_;
			}
			set
			{
				options_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool ClientStreaming
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return clientStreaming_;
				}
				return ClientStreamingDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				clientStreaming_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasClientStreaming => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool ServerStreaming
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return serverStreaming_;
				}
				return ServerStreamingDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				serverStreaming_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasServerStreaming => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodDescriptorProto()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodDescriptorProto(MethodDescriptorProto other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			name_ = other.name_;
			inputType_ = other.inputType_;
			outputType_ = other.outputType_;
			options_ = ((other.options_ != null) ? other.options_.Clone() : null);
			clientStreaming_ = other.clientStreaming_;
			serverStreaming_ = other.serverStreaming_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodDescriptorProto Clone()
		{
			return new MethodDescriptorProto(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearName()
		{
			name_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearInputType()
		{
			inputType_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearOutputType()
		{
			outputType_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearClientStreaming()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearServerStreaming()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as MethodDescriptorProto);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(MethodDescriptorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (InputType != other.InputType)
			{
				return false;
			}
			if (OutputType != other.OutputType)
			{
				return false;
			}
			if (!object.Equals(Options, other.Options))
			{
				return false;
			}
			if (ClientStreaming != other.ClientStreaming)
			{
				return false;
			}
			if (ServerStreaming != other.ServerStreaming)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasName)
			{
				num ^= Name.GetHashCode();
			}
			if (HasInputType)
			{
				num ^= InputType.GetHashCode();
			}
			if (HasOutputType)
			{
				num ^= OutputType.GetHashCode();
			}
			if (options_ != null)
			{
				num ^= Options.GetHashCode();
			}
			if (HasClientStreaming)
			{
				num ^= ClientStreaming.GetHashCode();
			}
			if (HasServerStreaming)
			{
				num ^= ServerStreaming.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasName)
			{
				output.WriteRawTag(10);
				output.WriteString(Name);
			}
			if (HasInputType)
			{
				output.WriteRawTag(18);
				output.WriteString(InputType);
			}
			if (HasOutputType)
			{
				output.WriteRawTag(26);
				output.WriteString(OutputType);
			}
			if (options_ != null)
			{
				output.WriteRawTag(34);
				output.WriteMessage(Options);
			}
			if (HasClientStreaming)
			{
				output.WriteRawTag(40);
				output.WriteBool(ClientStreaming);
			}
			if (HasServerStreaming)
			{
				output.WriteRawTag(48);
				output.WriteBool(ServerStreaming);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasName)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (HasInputType)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(InputType);
			}
			if (HasOutputType)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(OutputType);
			}
			if (options_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize(Options);
			}
			if (HasClientStreaming)
			{
				num += 2;
			}
			if (HasServerStreaming)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(MethodDescriptorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.HasName)
			{
				Name = other.Name;
			}
			if (other.HasInputType)
			{
				InputType = other.InputType;
			}
			if (other.HasOutputType)
			{
				OutputType = other.OutputType;
			}
			if (other.options_ != null)
			{
				if (options_ == null)
				{
					Options = new MethodOptions();
				}
				Options.MergeFrom(other.Options);
			}
			if (other.HasClientStreaming)
			{
				ClientStreaming = other.ClientStreaming;
			}
			if (other.HasServerStreaming)
			{
				ServerStreaming = other.ServerStreaming;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					InputType = input.ReadString();
					break;
				case 26u:
					OutputType = input.ReadString();
					break;
				case 34u:
					if (options_ == null)
					{
						Options = new MethodOptions();
					}
					input.ReadMessage(Options);
					break;
				case 40u:
					ClientStreaming = input.ReadBool();
					break;
				case 48u:
					ServerStreaming = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class FileOptions : IExtendableMessage<FileOptions>, IMessage<FileOptions>, IMessage, IEquatable<FileOptions>, IDeepCloneable<FileOptions>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public enum OptimizeMode
			{
				[OriginalName("SPEED")]
				Speed = 1,
				[OriginalName("CODE_SIZE")]
				CodeSize,
				[OriginalName("LITE_RUNTIME")]
				LiteRuntime
			}
		}

		private static readonly MessageParser<FileOptions> _parser = new MessageParser<FileOptions>(() => new FileOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<FileOptions> _extensions;

		private int _hasBits0;

		public const int JavaPackageFieldNumber = 1;

		private static readonly string JavaPackageDefaultValue = "";

		private string javaPackage_;

		public const int JavaOuterClassnameFieldNumber = 8;

		private static readonly string JavaOuterClassnameDefaultValue = "";

		private string javaOuterClassname_;

		public const int JavaMultipleFilesFieldNumber = 10;

		private static readonly bool JavaMultipleFilesDefaultValue = false;

		private bool javaMultipleFiles_;

		public const int JavaGenerateEqualsAndHashFieldNumber = 20;

		private static readonly bool JavaGenerateEqualsAndHashDefaultValue = false;

		private bool javaGenerateEqualsAndHash_;

		public const int JavaStringCheckUtf8FieldNumber = 27;

		private static readonly bool JavaStringCheckUtf8DefaultValue = false;

		private bool javaStringCheckUtf8_;

		public const int OptimizeForFieldNumber = 9;

		private static readonly Types.OptimizeMode OptimizeForDefaultValue = Types.OptimizeMode.Speed;

		private Types.OptimizeMode optimizeFor_;

		public const int GoPackageFieldNumber = 11;

		private static readonly string GoPackageDefaultValue = "";

		private string goPackage_;

		public const int CcGenericServicesFieldNumber = 16;

		private static readonly bool CcGenericServicesDefaultValue = false;

		private bool ccGenericServices_;

		public const int JavaGenericServicesFieldNumber = 17;

		private static readonly bool JavaGenericServicesDefaultValue = false;

		private bool javaGenericServices_;

		public const int PyGenericServicesFieldNumber = 18;

		private static readonly bool PyGenericServicesDefaultValue = false;

		private bool pyGenericServices_;

		public const int PhpGenericServicesFieldNumber = 42;

		private static readonly bool PhpGenericServicesDefaultValue = false;

		private bool phpGenericServices_;

		public const int DeprecatedFieldNumber = 23;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int CcEnableArenasFieldNumber = 31;

		private static readonly bool CcEnableArenasDefaultValue = true;

		private bool ccEnableArenas_;

		public const int ObjcClassPrefixFieldNumber = 36;

		private static readonly string ObjcClassPrefixDefaultValue = "";

		private string objcClassPrefix_;

		public const int CsharpNamespaceFieldNumber = 37;

		private static readonly string CsharpNamespaceDefaultValue = "";

		private string csharpNamespace_;

		public const int SwiftPrefixFieldNumber = 39;

		private static readonly string SwiftPrefixDefaultValue = "";

		private string swiftPrefix_;

		public const int PhpClassPrefixFieldNumber = 40;

		private static readonly string PhpClassPrefixDefaultValue = "";

		private string phpClassPrefix_;

		public const int PhpNamespaceFieldNumber = 41;

		private static readonly string PhpNamespaceDefaultValue = "";

		private string phpNamespace_;

		public const int PhpMetadataNamespaceFieldNumber = 44;

		private static readonly string PhpMetadataNamespaceDefaultValue = "";

		private string phpMetadataNamespace_;

		public const int RubyPackageFieldNumber = 45;

		private static readonly string RubyPackageDefaultValue = "";

		private string rubyPackage_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<FileOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FileOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[10];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string JavaPackage
		{
			get
			{
				return javaPackage_ ?? JavaPackageDefaultValue;
			}
			set
			{
				javaPackage_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaPackage => javaPackage_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string JavaOuterClassname
		{
			get
			{
				return javaOuterClassname_ ?? JavaOuterClassnameDefaultValue;
			}
			set
			{
				javaOuterClassname_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaOuterClassname => javaOuterClassname_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool JavaMultipleFiles
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return javaMultipleFiles_;
				}
				return JavaMultipleFilesDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				javaMultipleFiles_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaMultipleFiles => (_hasBits0 & 2) != 0;

		[Obsolete]
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool JavaGenerateEqualsAndHash
		{
			get
			{
				if ((_hasBits0 & 0x20) != 0)
				{
					return javaGenerateEqualsAndHash_;
				}
				return JavaGenerateEqualsAndHashDefaultValue;
			}
			set
			{
				_hasBits0 |= 32;
				javaGenerateEqualsAndHash_ = value;
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaGenerateEqualsAndHash => (_hasBits0 & 0x20) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool JavaStringCheckUtf8
		{
			get
			{
				if ((_hasBits0 & 0x80) != 0)
				{
					return javaStringCheckUtf8_;
				}
				return JavaStringCheckUtf8DefaultValue;
			}
			set
			{
				_hasBits0 |= 128;
				javaStringCheckUtf8_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaStringCheckUtf8 => (_hasBits0 & 0x80) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.OptimizeMode OptimizeFor
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return optimizeFor_;
				}
				return OptimizeForDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				optimizeFor_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasOptimizeFor => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string GoPackage
		{
			get
			{
				return goPackage_ ?? GoPackageDefaultValue;
			}
			set
			{
				goPackage_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasGoPackage => goPackage_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool CcGenericServices
		{
			get
			{
				if ((_hasBits0 & 4) != 0)
				{
					return ccGenericServices_;
				}
				return CcGenericServicesDefaultValue;
			}
			set
			{
				_hasBits0 |= 4;
				ccGenericServices_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasCcGenericServices => (_hasBits0 & 4) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool JavaGenericServices
		{
			get
			{
				if ((_hasBits0 & 8) != 0)
				{
					return javaGenericServices_;
				}
				return JavaGenericServicesDefaultValue;
			}
			set
			{
				_hasBits0 |= 8;
				javaGenericServices_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJavaGenericServices => (_hasBits0 & 8) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool PyGenericServices
		{
			get
			{
				if ((_hasBits0 & 0x10) != 0)
				{
					return pyGenericServices_;
				}
				return PyGenericServicesDefaultValue;
			}
			set
			{
				_hasBits0 |= 16;
				pyGenericServices_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPyGenericServices => (_hasBits0 & 0x10) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool PhpGenericServices
		{
			get
			{
				if ((_hasBits0 & 0x200) != 0)
				{
					return phpGenericServices_;
				}
				return PhpGenericServicesDefaultValue;
			}
			set
			{
				_hasBits0 |= 512;
				phpGenericServices_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPhpGenericServices => (_hasBits0 & 0x200) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 0x40) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 64;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 0x40) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool CcEnableArenas
		{
			get
			{
				if ((_hasBits0 & 0x100) != 0)
				{
					return ccEnableArenas_;
				}
				return CcEnableArenasDefaultValue;
			}
			set
			{
				_hasBits0 |= 256;
				ccEnableArenas_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasCcEnableArenas => (_hasBits0 & 0x100) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string ObjcClassPrefix
		{
			get
			{
				return objcClassPrefix_ ?? ObjcClassPrefixDefaultValue;
			}
			set
			{
				objcClassPrefix_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasObjcClassPrefix => objcClassPrefix_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string CsharpNamespace
		{
			get
			{
				return csharpNamespace_ ?? CsharpNamespaceDefaultValue;
			}
			set
			{
				csharpNamespace_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasCsharpNamespace => csharpNamespace_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string SwiftPrefix
		{
			get
			{
				return swiftPrefix_ ?? SwiftPrefixDefaultValue;
			}
			set
			{
				swiftPrefix_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasSwiftPrefix => swiftPrefix_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PhpClassPrefix
		{
			get
			{
				return phpClassPrefix_ ?? PhpClassPrefixDefaultValue;
			}
			set
			{
				phpClassPrefix_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPhpClassPrefix => phpClassPrefix_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PhpNamespace
		{
			get
			{
				return phpNamespace_ ?? PhpNamespaceDefaultValue;
			}
			set
			{
				phpNamespace_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPhpNamespace => phpNamespace_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string PhpMetadataNamespace
		{
			get
			{
				return phpMetadataNamespace_ ?? PhpMetadataNamespaceDefaultValue;
			}
			set
			{
				phpMetadataNamespace_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPhpMetadataNamespace => phpMetadataNamespace_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string RubyPackage
		{
			get
			{
				return rubyPackage_ ?? RubyPackageDefaultValue;
			}
			set
			{
				rubyPackage_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasRubyPackage => rubyPackage_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileOptions(FileOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			javaPackage_ = other.javaPackage_;
			javaOuterClassname_ = other.javaOuterClassname_;
			javaMultipleFiles_ = other.javaMultipleFiles_;
			javaGenerateEqualsAndHash_ = other.javaGenerateEqualsAndHash_;
			javaStringCheckUtf8_ = other.javaStringCheckUtf8_;
			optimizeFor_ = other.optimizeFor_;
			goPackage_ = other.goPackage_;
			ccGenericServices_ = other.ccGenericServices_;
			javaGenericServices_ = other.javaGenericServices_;
			pyGenericServices_ = other.pyGenericServices_;
			phpGenericServices_ = other.phpGenericServices_;
			deprecated_ = other.deprecated_;
			ccEnableArenas_ = other.ccEnableArenas_;
			objcClassPrefix_ = other.objcClassPrefix_;
			csharpNamespace_ = other.csharpNamespace_;
			swiftPrefix_ = other.swiftPrefix_;
			phpClassPrefix_ = other.phpClassPrefix_;
			phpNamespace_ = other.phpNamespace_;
			phpMetadataNamespace_ = other.phpMetadataNamespace_;
			rubyPackage_ = other.rubyPackage_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FileOptions Clone()
		{
			return new FileOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaPackage()
		{
			javaPackage_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaOuterClassname()
		{
			javaOuterClassname_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaMultipleFiles()
		{
			_hasBits0 &= -3;
		}

		[Obsolete]
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaGenerateEqualsAndHash()
		{
			_hasBits0 &= -33;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaStringCheckUtf8()
		{
			_hasBits0 &= -129;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearOptimizeFor()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearGoPackage()
		{
			goPackage_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearCcGenericServices()
		{
			_hasBits0 &= -5;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJavaGenericServices()
		{
			_hasBits0 &= -9;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPyGenericServices()
		{
			_hasBits0 &= -17;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPhpGenericServices()
		{
			_hasBits0 &= -513;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -65;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearCcEnableArenas()
		{
			_hasBits0 &= -257;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearObjcClassPrefix()
		{
			objcClassPrefix_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearCsharpNamespace()
		{
			csharpNamespace_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearSwiftPrefix()
		{
			swiftPrefix_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPhpClassPrefix()
		{
			phpClassPrefix_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPhpNamespace()
		{
			phpNamespace_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPhpMetadataNamespace()
		{
			phpMetadataNamespace_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearRubyPackage()
		{
			rubyPackage_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FileOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FileOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (JavaPackage != other.JavaPackage)
			{
				return false;
			}
			if (JavaOuterClassname != other.JavaOuterClassname)
			{
				return false;
			}
			if (JavaMultipleFiles != other.JavaMultipleFiles)
			{
				return false;
			}
			if (JavaGenerateEqualsAndHash != other.JavaGenerateEqualsAndHash)
			{
				return false;
			}
			if (JavaStringCheckUtf8 != other.JavaStringCheckUtf8)
			{
				return false;
			}
			if (OptimizeFor != other.OptimizeFor)
			{
				return false;
			}
			if (GoPackage != other.GoPackage)
			{
				return false;
			}
			if (CcGenericServices != other.CcGenericServices)
			{
				return false;
			}
			if (JavaGenericServices != other.JavaGenericServices)
			{
				return false;
			}
			if (PyGenericServices != other.PyGenericServices)
			{
				return false;
			}
			if (PhpGenericServices != other.PhpGenericServices)
			{
				return false;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (CcEnableArenas != other.CcEnableArenas)
			{
				return false;
			}
			if (ObjcClassPrefix != other.ObjcClassPrefix)
			{
				return false;
			}
			if (CsharpNamespace != other.CsharpNamespace)
			{
				return false;
			}
			if (SwiftPrefix != other.SwiftPrefix)
			{
				return false;
			}
			if (PhpClassPrefix != other.PhpClassPrefix)
			{
				return false;
			}
			if (PhpNamespace != other.PhpNamespace)
			{
				return false;
			}
			if (PhpMetadataNamespace != other.PhpMetadataNamespace)
			{
				return false;
			}
			if (RubyPackage != other.RubyPackage)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasJavaPackage)
			{
				num ^= JavaPackage.GetHashCode();
			}
			if (HasJavaOuterClassname)
			{
				num ^= JavaOuterClassname.GetHashCode();
			}
			if (HasJavaMultipleFiles)
			{
				num ^= JavaMultipleFiles.GetHashCode();
			}
			if (HasJavaGenerateEqualsAndHash)
			{
				num ^= JavaGenerateEqualsAndHash.GetHashCode();
			}
			if (HasJavaStringCheckUtf8)
			{
				num ^= JavaStringCheckUtf8.GetHashCode();
			}
			if (HasOptimizeFor)
			{
				num ^= OptimizeFor.GetHashCode();
			}
			if (HasGoPackage)
			{
				num ^= GoPackage.GetHashCode();
			}
			if (HasCcGenericServices)
			{
				num ^= CcGenericServices.GetHashCode();
			}
			if (HasJavaGenericServices)
			{
				num ^= JavaGenericServices.GetHashCode();
			}
			if (HasPyGenericServices)
			{
				num ^= PyGenericServices.GetHashCode();
			}
			if (HasPhpGenericServices)
			{
				num ^= PhpGenericServices.GetHashCode();
			}
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			if (HasCcEnableArenas)
			{
				num ^= CcEnableArenas.GetHashCode();
			}
			if (HasObjcClassPrefix)
			{
				num ^= ObjcClassPrefix.GetHashCode();
			}
			if (HasCsharpNamespace)
			{
				num ^= CsharpNamespace.GetHashCode();
			}
			if (HasSwiftPrefix)
			{
				num ^= SwiftPrefix.GetHashCode();
			}
			if (HasPhpClassPrefix)
			{
				num ^= PhpClassPrefix.GetHashCode();
			}
			if (HasPhpNamespace)
			{
				num ^= PhpNamespace.GetHashCode();
			}
			if (HasPhpMetadataNamespace)
			{
				num ^= PhpMetadataNamespace.GetHashCode();
			}
			if (HasRubyPackage)
			{
				num ^= RubyPackage.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasJavaPackage)
			{
				output.WriteRawTag(10);
				output.WriteString(JavaPackage);
			}
			if (HasJavaOuterClassname)
			{
				output.WriteRawTag(66);
				output.WriteString(JavaOuterClassname);
			}
			if (HasOptimizeFor)
			{
				output.WriteRawTag(72);
				output.WriteEnum((int)OptimizeFor);
			}
			if (HasJavaMultipleFiles)
			{
				output.WriteRawTag(80);
				output.WriteBool(JavaMultipleFiles);
			}
			if (HasGoPackage)
			{
				output.WriteRawTag(90);
				output.WriteString(GoPackage);
			}
			if (HasCcGenericServices)
			{
				output.WriteRawTag(128, 1);
				output.WriteBool(CcGenericServices);
			}
			if (HasJavaGenericServices)
			{
				output.WriteRawTag(136, 1);
				output.WriteBool(JavaGenericServices);
			}
			if (HasPyGenericServices)
			{
				output.WriteRawTag(144, 1);
				output.WriteBool(PyGenericServices);
			}
			if (HasJavaGenerateEqualsAndHash)
			{
				output.WriteRawTag(160, 1);
				output.WriteBool(JavaGenerateEqualsAndHash);
			}
			if (HasDeprecated)
			{
				output.WriteRawTag(184, 1);
				output.WriteBool(Deprecated);
			}
			if (HasJavaStringCheckUtf8)
			{
				output.WriteRawTag(216, 1);
				output.WriteBool(JavaStringCheckUtf8);
			}
			if (HasCcEnableArenas)
			{
				output.WriteRawTag(248, 1);
				output.WriteBool(CcEnableArenas);
			}
			if (HasObjcClassPrefix)
			{
				output.WriteRawTag(162, 2);
				output.WriteString(ObjcClassPrefix);
			}
			if (HasCsharpNamespace)
			{
				output.WriteRawTag(170, 2);
				output.WriteString(CsharpNamespace);
			}
			if (HasSwiftPrefix)
			{
				output.WriteRawTag(186, 2);
				output.WriteString(SwiftPrefix);
			}
			if (HasPhpClassPrefix)
			{
				output.WriteRawTag(194, 2);
				output.WriteString(PhpClassPrefix);
			}
			if (HasPhpNamespace)
			{
				output.WriteRawTag(202, 2);
				output.WriteString(PhpNamespace);
			}
			if (HasPhpGenericServices)
			{
				output.WriteRawTag(208, 2);
				output.WriteBool(PhpGenericServices);
			}
			if (HasPhpMetadataNamespace)
			{
				output.WriteRawTag(226, 2);
				output.WriteString(PhpMetadataNamespace);
			}
			if (HasRubyPackage)
			{
				output.WriteRawTag(234, 2);
				output.WriteString(RubyPackage);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasJavaPackage)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(JavaPackage);
			}
			if (HasJavaOuterClassname)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(JavaOuterClassname);
			}
			if (HasJavaMultipleFiles)
			{
				num += 2;
			}
			if (HasJavaGenerateEqualsAndHash)
			{
				num += 3;
			}
			if (HasJavaStringCheckUtf8)
			{
				num += 3;
			}
			if (HasOptimizeFor)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)OptimizeFor);
			}
			if (HasGoPackage)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(GoPackage);
			}
			if (HasCcGenericServices)
			{
				num += 3;
			}
			if (HasJavaGenericServices)
			{
				num += 3;
			}
			if (HasPyGenericServices)
			{
				num += 3;
			}
			if (HasPhpGenericServices)
			{
				num += 3;
			}
			if (HasDeprecated)
			{
				num += 3;
			}
			if (HasCcEnableArenas)
			{
				num += 3;
			}
			if (HasObjcClassPrefix)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(ObjcClassPrefix);
			}
			if (HasCsharpNamespace)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(CsharpNamespace);
			}
			if (HasSwiftPrefix)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(SwiftPrefix);
			}
			if (HasPhpClassPrefix)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(PhpClassPrefix);
			}
			if (HasPhpNamespace)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(PhpNamespace);
			}
			if (HasPhpMetadataNamespace)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(PhpMetadataNamespace);
			}
			if (HasRubyPackage)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(RubyPackage);
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FileOptions other)
		{
			if (other != null)
			{
				if (other.HasJavaPackage)
				{
					JavaPackage = other.JavaPackage;
				}
				if (other.HasJavaOuterClassname)
				{
					JavaOuterClassname = other.JavaOuterClassname;
				}
				if (other.HasJavaMultipleFiles)
				{
					JavaMultipleFiles = other.JavaMultipleFiles;
				}
				if (other.HasJavaGenerateEqualsAndHash)
				{
					JavaGenerateEqualsAndHash = other.JavaGenerateEqualsAndHash;
				}
				if (other.HasJavaStringCheckUtf8)
				{
					JavaStringCheckUtf8 = other.JavaStringCheckUtf8;
				}
				if (other.HasOptimizeFor)
				{
					OptimizeFor = other.OptimizeFor;
				}
				if (other.HasGoPackage)
				{
					GoPackage = other.GoPackage;
				}
				if (other.HasCcGenericServices)
				{
					CcGenericServices = other.CcGenericServices;
				}
				if (other.HasJavaGenericServices)
				{
					JavaGenericServices = other.JavaGenericServices;
				}
				if (other.HasPyGenericServices)
				{
					PyGenericServices = other.PyGenericServices;
				}
				if (other.HasPhpGenericServices)
				{
					PhpGenericServices = other.PhpGenericServices;
				}
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				if (other.HasCcEnableArenas)
				{
					CcEnableArenas = other.CcEnableArenas;
				}
				if (other.HasObjcClassPrefix)
				{
					ObjcClassPrefix = other.ObjcClassPrefix;
				}
				if (other.HasCsharpNamespace)
				{
					CsharpNamespace = other.CsharpNamespace;
				}
				if (other.HasSwiftPrefix)
				{
					SwiftPrefix = other.SwiftPrefix;
				}
				if (other.HasPhpClassPrefix)
				{
					PhpClassPrefix = other.PhpClassPrefix;
				}
				if (other.HasPhpNamespace)
				{
					PhpNamespace = other.PhpNamespace;
				}
				if (other.HasPhpMetadataNamespace)
				{
					PhpMetadataNamespace = other.PhpMetadataNamespace;
				}
				if (other.HasRubyPackage)
				{
					RubyPackage = other.RubyPackage;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 10u:
					JavaPackage = input.ReadString();
					continue;
				case 66u:
					JavaOuterClassname = input.ReadString();
					continue;
				case 72u:
					OptimizeFor = (Types.OptimizeMode)input.ReadEnum();
					continue;
				case 80u:
					JavaMultipleFiles = input.ReadBool();
					continue;
				case 90u:
					GoPackage = input.ReadString();
					continue;
				case 128u:
					CcGenericServices = input.ReadBool();
					continue;
				case 136u:
					JavaGenericServices = input.ReadBool();
					continue;
				case 144u:
					PyGenericServices = input.ReadBool();
					continue;
				case 160u:
					JavaGenerateEqualsAndHash = input.ReadBool();
					continue;
				case 184u:
					Deprecated = input.ReadBool();
					continue;
				case 216u:
					JavaStringCheckUtf8 = input.ReadBool();
					continue;
				case 248u:
					CcEnableArenas = input.ReadBool();
					continue;
				case 290u:
					ObjcClassPrefix = input.ReadString();
					continue;
				case 298u:
					CsharpNamespace = input.ReadString();
					continue;
				case 314u:
					SwiftPrefix = input.ReadString();
					continue;
				case 322u:
					PhpClassPrefix = input.ReadString();
					continue;
				case 330u:
					PhpNamespace = input.ReadString();
					continue;
				case 336u:
					PhpGenericServices = input.ReadBool();
					continue;
				case 354u:
					PhpMetadataNamespace = input.ReadString();
					continue;
				case 362u:
					RubyPackage = input.ReadString();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<FileOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<FileOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<FileOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<FileOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<FileOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<FileOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<FileOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class MessageOptions : IExtendableMessage<MessageOptions>, IMessage<MessageOptions>, IMessage, IEquatable<MessageOptions>, IDeepCloneable<MessageOptions>, IBufferMessage
	{
		private static readonly MessageParser<MessageOptions> _parser = new MessageParser<MessageOptions>(() => new MessageOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<MessageOptions> _extensions;

		private int _hasBits0;

		public const int MessageSetWireFormatFieldNumber = 1;

		private static readonly bool MessageSetWireFormatDefaultValue = false;

		private bool messageSetWireFormat_;

		public const int NoStandardDescriptorAccessorFieldNumber = 2;

		private static readonly bool NoStandardDescriptorAccessorDefaultValue = false;

		private bool noStandardDescriptorAccessor_;

		public const int DeprecatedFieldNumber = 3;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int MapEntryFieldNumber = 7;

		private static readonly bool MapEntryDefaultValue = false;

		private bool mapEntry_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<MessageOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<MessageOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[11];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool MessageSetWireFormat
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return messageSetWireFormat_;
				}
				return MessageSetWireFormatDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				messageSetWireFormat_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasMessageSetWireFormat => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool NoStandardDescriptorAccessor
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return noStandardDescriptorAccessor_;
				}
				return NoStandardDescriptorAccessorDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				noStandardDescriptorAccessor_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasNoStandardDescriptorAccessor => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 4) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 4;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 4) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool MapEntry
		{
			get
			{
				if ((_hasBits0 & 8) != 0)
				{
					return mapEntry_;
				}
				return MapEntryDefaultValue;
			}
			set
			{
				_hasBits0 |= 8;
				mapEntry_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasMapEntry => (_hasBits0 & 8) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MessageOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MessageOptions(MessageOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			messageSetWireFormat_ = other.messageSetWireFormat_;
			noStandardDescriptorAccessor_ = other.noStandardDescriptorAccessor_;
			deprecated_ = other.deprecated_;
			mapEntry_ = other.mapEntry_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MessageOptions Clone()
		{
			return new MessageOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearMessageSetWireFormat()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearNoStandardDescriptorAccessor()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -5;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearMapEntry()
		{
			_hasBits0 &= -9;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as MessageOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(MessageOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (MessageSetWireFormat != other.MessageSetWireFormat)
			{
				return false;
			}
			if (NoStandardDescriptorAccessor != other.NoStandardDescriptorAccessor)
			{
				return false;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (MapEntry != other.MapEntry)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasMessageSetWireFormat)
			{
				num ^= MessageSetWireFormat.GetHashCode();
			}
			if (HasNoStandardDescriptorAccessor)
			{
				num ^= NoStandardDescriptorAccessor.GetHashCode();
			}
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			if (HasMapEntry)
			{
				num ^= MapEntry.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasMessageSetWireFormat)
			{
				output.WriteRawTag(8);
				output.WriteBool(MessageSetWireFormat);
			}
			if (HasNoStandardDescriptorAccessor)
			{
				output.WriteRawTag(16);
				output.WriteBool(NoStandardDescriptorAccessor);
			}
			if (HasDeprecated)
			{
				output.WriteRawTag(24);
				output.WriteBool(Deprecated);
			}
			if (HasMapEntry)
			{
				output.WriteRawTag(56);
				output.WriteBool(MapEntry);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasMessageSetWireFormat)
			{
				num += 2;
			}
			if (HasNoStandardDescriptorAccessor)
			{
				num += 2;
			}
			if (HasDeprecated)
			{
				num += 2;
			}
			if (HasMapEntry)
			{
				num += 2;
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(MessageOptions other)
		{
			if (other != null)
			{
				if (other.HasMessageSetWireFormat)
				{
					MessageSetWireFormat = other.MessageSetWireFormat;
				}
				if (other.HasNoStandardDescriptorAccessor)
				{
					NoStandardDescriptorAccessor = other.NoStandardDescriptorAccessor;
				}
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				if (other.HasMapEntry)
				{
					MapEntry = other.MapEntry;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 8u:
					MessageSetWireFormat = input.ReadBool();
					continue;
				case 16u:
					NoStandardDescriptorAccessor = input.ReadBool();
					continue;
				case 24u:
					Deprecated = input.ReadBool();
					continue;
				case 56u:
					MapEntry = input.ReadBool();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<MessageOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<MessageOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<MessageOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<MessageOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<MessageOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<MessageOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<MessageOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class FieldOptions : IExtendableMessage<FieldOptions>, IMessage<FieldOptions>, IMessage, IEquatable<FieldOptions>, IDeepCloneable<FieldOptions>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public enum CType
			{
				[OriginalName("STRING")]
				String,
				[OriginalName("CORD")]
				Cord,
				[OriginalName("STRING_PIECE")]
				StringPiece
			}

			public enum JSType
			{
				[OriginalName("JS_NORMAL")]
				JsNormal,
				[OriginalName("JS_STRING")]
				JsString,
				[OriginalName("JS_NUMBER")]
				JsNumber
			}
		}

		private static readonly MessageParser<FieldOptions> _parser = new MessageParser<FieldOptions>(() => new FieldOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<FieldOptions> _extensions;

		private int _hasBits0;

		public const int CtypeFieldNumber = 1;

		private static readonly Types.CType CtypeDefaultValue = Types.CType.String;

		private Types.CType ctype_;

		public const int PackedFieldNumber = 2;

		private static readonly bool PackedDefaultValue = false;

		private bool packed_;

		public const int JstypeFieldNumber = 6;

		private static readonly Types.JSType JstypeDefaultValue = Types.JSType.JsNormal;

		private Types.JSType jstype_;

		public const int LazyFieldNumber = 5;

		private static readonly bool LazyDefaultValue = false;

		private bool lazy_;

		public const int UnverifiedLazyFieldNumber = 15;

		private static readonly bool UnverifiedLazyDefaultValue = false;

		private bool unverifiedLazy_;

		public const int DeprecatedFieldNumber = 3;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int WeakFieldNumber = 10;

		private static readonly bool WeakDefaultValue = false;

		private bool weak_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<FieldOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<FieldOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[12];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.CType Ctype
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return ctype_;
				}
				return CtypeDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				ctype_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasCtype => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Packed
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return packed_;
				}
				return PackedDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				packed_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPacked => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.JSType Jstype
		{
			get
			{
				if ((_hasBits0 & 0x10) != 0)
				{
					return jstype_;
				}
				return JstypeDefaultValue;
			}
			set
			{
				_hasBits0 |= 16;
				jstype_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasJstype => (_hasBits0 & 0x10) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Lazy
		{
			get
			{
				if ((_hasBits0 & 8) != 0)
				{
					return lazy_;
				}
				return LazyDefaultValue;
			}
			set
			{
				_hasBits0 |= 8;
				lazy_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasLazy => (_hasBits0 & 8) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool UnverifiedLazy
		{
			get
			{
				if ((_hasBits0 & 0x40) != 0)
				{
					return unverifiedLazy_;
				}
				return UnverifiedLazyDefaultValue;
			}
			set
			{
				_hasBits0 |= 64;
				unverifiedLazy_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasUnverifiedLazy => (_hasBits0 & 0x40) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 4) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 4;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 4) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Weak
		{
			get
			{
				if ((_hasBits0 & 0x20) != 0)
				{
					return weak_;
				}
				return WeakDefaultValue;
			}
			set
			{
				_hasBits0 |= 32;
				weak_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasWeak => (_hasBits0 & 0x20) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldOptions(FieldOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			ctype_ = other.ctype_;
			packed_ = other.packed_;
			jstype_ = other.jstype_;
			lazy_ = other.lazy_;
			unverifiedLazy_ = other.unverifiedLazy_;
			deprecated_ = other.deprecated_;
			weak_ = other.weak_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public FieldOptions Clone()
		{
			return new FieldOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearCtype()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPacked()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearJstype()
		{
			_hasBits0 &= -17;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearLazy()
		{
			_hasBits0 &= -9;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearUnverifiedLazy()
		{
			_hasBits0 &= -65;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -5;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearWeak()
		{
			_hasBits0 &= -33;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as FieldOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(FieldOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Ctype != other.Ctype)
			{
				return false;
			}
			if (Packed != other.Packed)
			{
				return false;
			}
			if (Jstype != other.Jstype)
			{
				return false;
			}
			if (Lazy != other.Lazy)
			{
				return false;
			}
			if (UnverifiedLazy != other.UnverifiedLazy)
			{
				return false;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (Weak != other.Weak)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasCtype)
			{
				num ^= Ctype.GetHashCode();
			}
			if (HasPacked)
			{
				num ^= Packed.GetHashCode();
			}
			if (HasJstype)
			{
				num ^= Jstype.GetHashCode();
			}
			if (HasLazy)
			{
				num ^= Lazy.GetHashCode();
			}
			if (HasUnverifiedLazy)
			{
				num ^= UnverifiedLazy.GetHashCode();
			}
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			if (HasWeak)
			{
				num ^= Weak.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasCtype)
			{
				output.WriteRawTag(8);
				output.WriteEnum((int)Ctype);
			}
			if (HasPacked)
			{
				output.WriteRawTag(16);
				output.WriteBool(Packed);
			}
			if (HasDeprecated)
			{
				output.WriteRawTag(24);
				output.WriteBool(Deprecated);
			}
			if (HasLazy)
			{
				output.WriteRawTag(40);
				output.WriteBool(Lazy);
			}
			if (HasJstype)
			{
				output.WriteRawTag(48);
				output.WriteEnum((int)Jstype);
			}
			if (HasWeak)
			{
				output.WriteRawTag(80);
				output.WriteBool(Weak);
			}
			if (HasUnverifiedLazy)
			{
				output.WriteRawTag(120);
				output.WriteBool(UnverifiedLazy);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasCtype)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Ctype);
			}
			if (HasPacked)
			{
				num += 2;
			}
			if (HasJstype)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Jstype);
			}
			if (HasLazy)
			{
				num += 2;
			}
			if (HasUnverifiedLazy)
			{
				num += 2;
			}
			if (HasDeprecated)
			{
				num += 2;
			}
			if (HasWeak)
			{
				num += 2;
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(FieldOptions other)
		{
			if (other != null)
			{
				if (other.HasCtype)
				{
					Ctype = other.Ctype;
				}
				if (other.HasPacked)
				{
					Packed = other.Packed;
				}
				if (other.HasJstype)
				{
					Jstype = other.Jstype;
				}
				if (other.HasLazy)
				{
					Lazy = other.Lazy;
				}
				if (other.HasUnverifiedLazy)
				{
					UnverifiedLazy = other.UnverifiedLazy;
				}
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				if (other.HasWeak)
				{
					Weak = other.Weak;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 8u:
					Ctype = (Types.CType)input.ReadEnum();
					continue;
				case 16u:
					Packed = input.ReadBool();
					continue;
				case 24u:
					Deprecated = input.ReadBool();
					continue;
				case 40u:
					Lazy = input.ReadBool();
					continue;
				case 48u:
					Jstype = (Types.JSType)input.ReadEnum();
					continue;
				case 80u:
					Weak = input.ReadBool();
					continue;
				case 120u:
					UnverifiedLazy = input.ReadBool();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<FieldOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<FieldOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<FieldOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<FieldOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<FieldOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<FieldOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<FieldOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class OneofOptions : IExtendableMessage<OneofOptions>, IMessage<OneofOptions>, IMessage, IEquatable<OneofOptions>, IDeepCloneable<OneofOptions>, IBufferMessage
	{
		private static readonly MessageParser<OneofOptions> _parser = new MessageParser<OneofOptions>(() => new OneofOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<OneofOptions> _extensions;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<OneofOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<OneofOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[13];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofOptions(OneofOptions other)
			: this()
		{
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public OneofOptions Clone()
		{
			return new OneofOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as OneofOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(OneofOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(OneofOptions other)
		{
			if (other != null)
			{
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 7994)
				{
					if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
					{
						_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					}
				}
				else
				{
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<OneofOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<OneofOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<OneofOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<OneofOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<OneofOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<OneofOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<OneofOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class EnumOptions : IExtendableMessage<EnumOptions>, IMessage<EnumOptions>, IMessage, IEquatable<EnumOptions>, IDeepCloneable<EnumOptions>, IBufferMessage
	{
		private static readonly MessageParser<EnumOptions> _parser = new MessageParser<EnumOptions>(() => new EnumOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<EnumOptions> _extensions;

		private int _hasBits0;

		public const int AllowAliasFieldNumber = 2;

		private static readonly bool AllowAliasDefaultValue = false;

		private bool allowAlias_;

		public const int DeprecatedFieldNumber = 3;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<EnumOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<EnumOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[14];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool AllowAlias
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return allowAlias_;
				}
				return AllowAliasDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				allowAlias_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasAllowAlias => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumOptions(EnumOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			allowAlias_ = other.allowAlias_;
			deprecated_ = other.deprecated_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumOptions Clone()
		{
			return new EnumOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearAllowAlias()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as EnumOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(EnumOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (AllowAlias != other.AllowAlias)
			{
				return false;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasAllowAlias)
			{
				num ^= AllowAlias.GetHashCode();
			}
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasAllowAlias)
			{
				output.WriteRawTag(16);
				output.WriteBool(AllowAlias);
			}
			if (HasDeprecated)
			{
				output.WriteRawTag(24);
				output.WriteBool(Deprecated);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasAllowAlias)
			{
				num += 2;
			}
			if (HasDeprecated)
			{
				num += 2;
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(EnumOptions other)
		{
			if (other != null)
			{
				if (other.HasAllowAlias)
				{
					AllowAlias = other.AllowAlias;
				}
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 16u:
					AllowAlias = input.ReadBool();
					continue;
				case 24u:
					Deprecated = input.ReadBool();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<EnumOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<EnumOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<EnumOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<EnumOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<EnumOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<EnumOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<EnumOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class EnumValueOptions : IExtendableMessage<EnumValueOptions>, IMessage<EnumValueOptions>, IMessage, IEquatable<EnumValueOptions>, IDeepCloneable<EnumValueOptions>, IBufferMessage
	{
		private static readonly MessageParser<EnumValueOptions> _parser = new MessageParser<EnumValueOptions>(() => new EnumValueOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<EnumValueOptions> _extensions;

		private int _hasBits0;

		public const int DeprecatedFieldNumber = 1;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<EnumValueOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<EnumValueOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[15];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueOptions(EnumValueOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			deprecated_ = other.deprecated_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public EnumValueOptions Clone()
		{
			return new EnumValueOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as EnumValueOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(EnumValueOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasDeprecated)
			{
				output.WriteRawTag(8);
				output.WriteBool(Deprecated);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasDeprecated)
			{
				num += 2;
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(EnumValueOptions other)
		{
			if (other != null)
			{
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 8u:
					Deprecated = input.ReadBool();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<EnumValueOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<EnumValueOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<EnumValueOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<EnumValueOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<EnumValueOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<EnumValueOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<EnumValueOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class ServiceOptions : IExtendableMessage<ServiceOptions>, IMessage<ServiceOptions>, IMessage, IEquatable<ServiceOptions>, IDeepCloneable<ServiceOptions>, IBufferMessage
	{
		private static readonly MessageParser<ServiceOptions> _parser = new MessageParser<ServiceOptions>(() => new ServiceOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<ServiceOptions> _extensions;

		private int _hasBits0;

		public const int DeprecatedFieldNumber = 33;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<ServiceOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<ServiceOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[16];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceOptions(ServiceOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			deprecated_ = other.deprecated_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ServiceOptions Clone()
		{
			return new ServiceOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as ServiceOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(ServiceOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasDeprecated)
			{
				output.WriteRawTag(136, 2);
				output.WriteBool(Deprecated);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasDeprecated)
			{
				num += 3;
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(ServiceOptions other)
		{
			if (other != null)
			{
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 264u:
					Deprecated = input.ReadBool();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<ServiceOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<ServiceOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<ServiceOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<ServiceOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<ServiceOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<ServiceOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<ServiceOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class MethodOptions : IExtendableMessage<MethodOptions>, IMessage<MethodOptions>, IMessage, IEquatable<MethodOptions>, IDeepCloneable<MethodOptions>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public enum IdempotencyLevel
			{
				[OriginalName("IDEMPOTENCY_UNKNOWN")]
				IdempotencyUnknown,
				[OriginalName("NO_SIDE_EFFECTS")]
				NoSideEffects,
				[OriginalName("IDEMPOTENT")]
				Idempotent
			}
		}

		private static readonly MessageParser<MethodOptions> _parser = new MessageParser<MethodOptions>(() => new MethodOptions());

		private UnknownFieldSet _unknownFields;

		internal ExtensionSet<MethodOptions> _extensions;

		private int _hasBits0;

		public const int DeprecatedFieldNumber = 33;

		private static readonly bool DeprecatedDefaultValue = false;

		private bool deprecated_;

		public const int IdempotencyLevelFieldNumber = 34;

		private static readonly Types.IdempotencyLevel IdempotencyLevelDefaultValue = Types.IdempotencyLevel.IdempotencyUnknown;

		private Types.IdempotencyLevel idempotencyLevel_;

		public const int UninterpretedOptionFieldNumber = 999;

		private static readonly FieldCodec<UninterpretedOption> _repeated_uninterpretedOption_codec = FieldCodec.ForMessage(7994u, Google.Protobuf.Reflection.UninterpretedOption.Parser);

		private readonly RepeatedField<UninterpretedOption> uninterpretedOption_ = new RepeatedField<UninterpretedOption>();

		private ExtensionSet<MethodOptions> _Extensions => _extensions;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<MethodOptions> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[17];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Deprecated
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return deprecated_;
				}
				return DeprecatedDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				deprecated_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDeprecated => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public Types.IdempotencyLevel IdempotencyLevel
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return idempotencyLevel_;
				}
				return IdempotencyLevelDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				idempotencyLevel_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasIdempotencyLevel => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<UninterpretedOption> UninterpretedOption => uninterpretedOption_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodOptions()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodOptions(MethodOptions other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			deprecated_ = other.deprecated_;
			idempotencyLevel_ = other.idempotencyLevel_;
			uninterpretedOption_ = other.uninterpretedOption_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
			_extensions = ExtensionSet.Clone(other._extensions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public MethodOptions Clone()
		{
			return new MethodOptions(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDeprecated()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearIdempotencyLevel()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as MethodOptions);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(MethodOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Deprecated != other.Deprecated)
			{
				return false;
			}
			if (IdempotencyLevel != other.IdempotencyLevel)
			{
				return false;
			}
			if (!uninterpretedOption_.Equals(other.uninterpretedOption_))
			{
				return false;
			}
			if (!object.Equals(_extensions, other._extensions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			if (HasDeprecated)
			{
				num ^= Deprecated.GetHashCode();
			}
			if (HasIdempotencyLevel)
			{
				num ^= IdempotencyLevel.GetHashCode();
			}
			num ^= uninterpretedOption_.GetHashCode();
			if (_extensions != null)
			{
				num ^= _extensions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			if (HasDeprecated)
			{
				output.WriteRawTag(136, 2);
				output.WriteBool(Deprecated);
			}
			if (HasIdempotencyLevel)
			{
				output.WriteRawTag(144, 2);
				output.WriteEnum((int)IdempotencyLevel);
			}
			uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				_extensions.WriteTo(ref output);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			if (HasDeprecated)
			{
				num += 3;
			}
			if (HasIdempotencyLevel)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)IdempotencyLevel);
			}
			num += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
			if (_extensions != null)
			{
				num += _extensions.CalculateSize();
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(MethodOptions other)
		{
			if (other != null)
			{
				if (other.HasDeprecated)
				{
					Deprecated = other.Deprecated;
				}
				if (other.HasIdempotencyLevel)
				{
					IdempotencyLevel = other.IdempotencyLevel;
				}
				uninterpretedOption_.Add(other.uninterpretedOption_);
				ExtensionSet.MergeFrom(ref _extensions, other._extensions);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				case 264u:
					Deprecated = input.ReadBool();
					continue;
				case 272u:
					IdempotencyLevel = (Types.IdempotencyLevel)input.ReadEnum();
					continue;
				case 7994u:
					uninterpretedOption_.AddEntriesFrom(ref input, _repeated_uninterpretedOption_codec);
					continue;
				}
				if (!ExtensionSet.TryMergeFieldFrom(ref _extensions, ref input))
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
			}
		}

		public TValue GetExtension<TValue>(Extension<MethodOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetExtension<TValue>(RepeatedExtension<MethodOptions, TValue> extension)
		{
			return ExtensionSet.Get(ref _extensions, extension);
		}

		public RepeatedField<TValue> GetOrInitializeExtension<TValue>(RepeatedExtension<MethodOptions, TValue> extension)
		{
			return ExtensionSet.GetOrInitialize(ref _extensions, extension);
		}

		public void SetExtension<TValue>(Extension<MethodOptions, TValue> extension, TValue value)
		{
			ExtensionSet.Set(ref _extensions, extension, value);
		}

		public bool HasExtension<TValue>(Extension<MethodOptions, TValue> extension)
		{
			return ExtensionSet.Has(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(Extension<MethodOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}

		public void ClearExtension<TValue>(RepeatedExtension<MethodOptions, TValue> extension)
		{
			ExtensionSet.Clear(ref _extensions, extension);
		}
	}
	public sealed class UninterpretedOption : IMessage<UninterpretedOption>, IMessage, IEquatable<UninterpretedOption>, IDeepCloneable<UninterpretedOption>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public sealed class NamePart : IMessage<NamePart>, IMessage, IEquatable<NamePart>, IDeepCloneable<NamePart>, IBufferMessage
			{
				private static readonly MessageParser<NamePart> _parser = new MessageParser<NamePart>(() => new NamePart());

				private UnknownFieldSet _unknownFields;

				private int _hasBits0;

				public const int NamePart_FieldNumber = 1;

				private static readonly string NamePart_DefaultValue = "";

				private string namePart_;

				public const int IsExtensionFieldNumber = 2;

				private static readonly bool IsExtensionDefaultValue = false;

				private bool isExtension_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<NamePart> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => UninterpretedOption.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public string NamePart_
				{
					get
					{
						return namePart_ ?? NamePart_DefaultValue;
					}
					set
					{
						namePart_ = ProtoPreconditions.CheckNotNull(value, "value");
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasNamePart_ => namePart_ != null;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool IsExtension
				{
					get
					{
						if ((_hasBits0 & 1) != 0)
						{
							return isExtension_;
						}
						return IsExtensionDefaultValue;
					}
					set
					{
						_hasBits0 |= 1;
						isExtension_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasIsExtension => (_hasBits0 & 1) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public NamePart()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public NamePart(NamePart other)
					: this()
				{
					_hasBits0 = other._hasBits0;
					namePart_ = other.namePart_;
					isExtension_ = other.isExtension_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public NamePart Clone()
				{
					return new NamePart(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearNamePart_()
				{
					namePart_ = null;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearIsExtension()
				{
					_hasBits0 &= -2;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as NamePart);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(NamePart other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (NamePart_ != other.NamePart_)
					{
						return false;
					}
					if (IsExtension != other.IsExtension)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					if (HasNamePart_)
					{
						num ^= NamePart_.GetHashCode();
					}
					if (HasIsExtension)
					{
						num ^= IsExtension.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					if (HasNamePart_)
					{
						output.WriteRawTag(10);
						output.WriteString(NamePart_);
					}
					if (HasIsExtension)
					{
						output.WriteRawTag(16);
						output.WriteBool(IsExtension);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					if (HasNamePart_)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(NamePart_);
					}
					if (HasIsExtension)
					{
						num += 2;
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(NamePart other)
				{
					if (other != null)
					{
						if (other.HasNamePart_)
						{
							NamePart_ = other.NamePart_;
						}
						if (other.HasIsExtension)
						{
							IsExtension = other.IsExtension;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 10u:
							NamePart_ = input.ReadString();
							break;
						case 16u:
							IsExtension = input.ReadBool();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<UninterpretedOption> _parser = new MessageParser<UninterpretedOption>(() => new UninterpretedOption());

		private UnknownFieldSet _unknownFields;

		private int _hasBits0;

		public const int NameFieldNumber = 2;

		private static readonly FieldCodec<Types.NamePart> _repeated_name_codec = FieldCodec.ForMessage(18u, Types.NamePart.Parser);

		private readonly RepeatedField<Types.NamePart> name_ = new RepeatedField<Types.NamePart>();

		public const int IdentifierValueFieldNumber = 3;

		private static readonly string IdentifierValueDefaultValue = "";

		private string identifierValue_;

		public const int PositiveIntValueFieldNumber = 4;

		private static readonly ulong PositiveIntValueDefaultValue = 0uL;

		private ulong positiveIntValue_;

		public const int NegativeIntValueFieldNumber = 5;

		private static readonly long NegativeIntValueDefaultValue = 0L;

		private long negativeIntValue_;

		public const int DoubleValueFieldNumber = 6;

		private static readonly double DoubleValueDefaultValue = 0.0;

		private double doubleValue_;

		public const int StringValueFieldNumber = 7;

		private static readonly ByteString StringValueDefaultValue = ByteString.Empty;

		private ByteString stringValue_;

		public const int AggregateValueFieldNumber = 8;

		private static readonly string AggregateValueDefaultValue = "";

		private string aggregateValue_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<UninterpretedOption> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[18];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.NamePart> Name => name_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string IdentifierValue
		{
			get
			{
				return identifierValue_ ?? IdentifierValueDefaultValue;
			}
			set
			{
				identifierValue_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasIdentifierValue => identifierValue_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ulong PositiveIntValue
		{
			get
			{
				if ((_hasBits0 & 1) != 0)
				{
					return positiveIntValue_;
				}
				return PositiveIntValueDefaultValue;
			}
			set
			{
				_hasBits0 |= 1;
				positiveIntValue_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasPositiveIntValue => (_hasBits0 & 1) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public long NegativeIntValue
		{
			get
			{
				if ((_hasBits0 & 2) != 0)
				{
					return negativeIntValue_;
				}
				return NegativeIntValueDefaultValue;
			}
			set
			{
				_hasBits0 |= 2;
				negativeIntValue_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasNegativeIntValue => (_hasBits0 & 2) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public double DoubleValue
		{
			get
			{
				if ((_hasBits0 & 4) != 0)
				{
					return doubleValue_;
				}
				return DoubleValueDefaultValue;
			}
			set
			{
				_hasBits0 |= 4;
				doubleValue_ = value;
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasDoubleValue => (_hasBits0 & 4) != 0;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public ByteString StringValue
		{
			get
			{
				return stringValue_ ?? StringValueDefaultValue;
			}
			set
			{
				stringValue_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasStringValue => stringValue_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public string AggregateValue
		{
			get
			{
				return aggregateValue_ ?? AggregateValueDefaultValue;
			}
			set
			{
				aggregateValue_ = ProtoPreconditions.CheckNotNull(value, "value");
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool HasAggregateValue => aggregateValue_ != null;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UninterpretedOption()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UninterpretedOption(UninterpretedOption other)
			: this()
		{
			_hasBits0 = other._hasBits0;
			name_ = other.name_.Clone();
			identifierValue_ = other.identifierValue_;
			positiveIntValue_ = other.positiveIntValue_;
			negativeIntValue_ = other.negativeIntValue_;
			doubleValue_ = other.doubleValue_;
			stringValue_ = other.stringValue_;
			aggregateValue_ = other.aggregateValue_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public UninterpretedOption Clone()
		{
			return new UninterpretedOption(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearIdentifierValue()
		{
			identifierValue_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearPositiveIntValue()
		{
			_hasBits0 &= -2;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearNegativeIntValue()
		{
			_hasBits0 &= -3;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearDoubleValue()
		{
			_hasBits0 &= -5;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearStringValue()
		{
			stringValue_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void ClearAggregateValue()
		{
			aggregateValue_ = null;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as UninterpretedOption);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(UninterpretedOption other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!name_.Equals(other.name_))
			{
				return false;
			}
			if (IdentifierValue != other.IdentifierValue)
			{
				return false;
			}
			if (PositiveIntValue != other.PositiveIntValue)
			{
				return false;
			}
			if (NegativeIntValue != other.NegativeIntValue)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DoubleValue, other.DoubleValue))
			{
				return false;
			}
			if (StringValue != other.StringValue)
			{
				return false;
			}
			if (AggregateValue != other.AggregateValue)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= name_.GetHashCode();
			if (HasIdentifierValue)
			{
				num ^= IdentifierValue.GetHashCode();
			}
			if (HasPositiveIntValue)
			{
				num ^= PositiveIntValue.GetHashCode();
			}
			if (HasNegativeIntValue)
			{
				num ^= NegativeIntValue.GetHashCode();
			}
			if (HasDoubleValue)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DoubleValue);
			}
			if (HasStringValue)
			{
				num ^= StringValue.GetHashCode();
			}
			if (HasAggregateValue)
			{
				num ^= AggregateValue.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			name_.WriteTo(ref output, _repeated_name_codec);
			if (HasIdentifierValue)
			{
				output.WriteRawTag(26);
				output.WriteString(IdentifierValue);
			}
			if (HasPositiveIntValue)
			{
				output.WriteRawTag(32);
				output.WriteUInt64(PositiveIntValue);
			}
			if (HasNegativeIntValue)
			{
				output.WriteRawTag(40);
				output.WriteInt64(NegativeIntValue);
			}
			if (HasDoubleValue)
			{
				output.WriteRawTag(49);
				output.WriteDouble(DoubleValue);
			}
			if (HasStringValue)
			{
				output.WriteRawTag(58);
				output.WriteBytes(StringValue);
			}
			if (HasAggregateValue)
			{
				output.WriteRawTag(66);
				output.WriteString(AggregateValue);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += name_.CalculateSize(_repeated_name_codec);
			if (HasIdentifierValue)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(IdentifierValue);
			}
			if (HasPositiveIntValue)
			{
				num += 1 + CodedOutputStream.ComputeUInt64Size(PositiveIntValue);
			}
			if (HasNegativeIntValue)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(NegativeIntValue);
			}
			if (HasDoubleValue)
			{
				num += 9;
			}
			if (HasStringValue)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(StringValue);
			}
			if (HasAggregateValue)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(AggregateValue);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(UninterpretedOption other)
		{
			if (other != null)
			{
				name_.Add(other.name_);
				if (other.HasIdentifierValue)
				{
					IdentifierValue = other.IdentifierValue;
				}
				if (other.HasPositiveIntValue)
				{
					PositiveIntValue = other.PositiveIntValue;
				}
				if (other.HasNegativeIntValue)
				{
					NegativeIntValue = other.NegativeIntValue;
				}
				if (other.HasDoubleValue)
				{
					DoubleValue = other.DoubleValue;
				}
				if (other.HasStringValue)
				{
					StringValue = other.StringValue;
				}
				if (other.HasAggregateValue)
				{
					AggregateValue = other.AggregateValue;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
					break;
				case 18u:
					name_.AddEntriesFrom(ref input, _repeated_name_codec);
					break;
				case 26u:
					IdentifierValue = input.ReadString();
					break;
				case 32u:
					PositiveIntValue = input.ReadUInt64();
					break;
				case 40u:
					NegativeIntValue = input.ReadInt64();
					break;
				case 49u:
					DoubleValue = input.ReadDouble();
					break;
				case 58u:
					StringValue = input.ReadBytes();
					break;
				case 66u:
					AggregateValue = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class SourceCodeInfo : IMessage<SourceCodeInfo>, IMessage, IEquatable<SourceCodeInfo>, IDeepCloneable<SourceCodeInfo>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public sealed class Location : IMessage<Location>, IMessage, IEquatable<Location>, IDeepCloneable<Location>, IBufferMessage
			{
				private static readonly MessageParser<Location> _parser = new MessageParser<Location>(() => new Location());

				private UnknownFieldSet _unknownFields;

				public const int PathFieldNumber = 1;

				private static readonly FieldCodec<int> _repeated_path_codec = FieldCodec.ForInt32(10u);

				private readonly RepeatedField<int> path_ = new RepeatedField<int>();

				public const int SpanFieldNumber = 2;

				private static readonly FieldCodec<int> _repeated_span_codec = FieldCodec.ForInt32(18u);

				private readonly RepeatedField<int> span_ = new RepeatedField<int>();

				public const int LeadingCommentsFieldNumber = 3;

				private static readonly string LeadingCommentsDefaultValue = "";

				private string leadingComments_;

				public const int TrailingCommentsFieldNumber = 4;

				private static readonly string TrailingCommentsDefaultValue = "";

				private string trailingComments_;

				public const int LeadingDetachedCommentsFieldNumber = 6;

				private static readonly FieldCodec<string> _repeated_leadingDetachedComments_codec = FieldCodec.ForString(50u);

				private readonly RepeatedField<string> leadingDetachedComments_ = new RepeatedField<string>();

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<Location> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => SourceCodeInfo.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public RepeatedField<int> Path => path_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public RepeatedField<int> Span => span_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public string LeadingComments
				{
					get
					{
						return leadingComments_ ?? LeadingCommentsDefaultValue;
					}
					set
					{
						leadingComments_ = ProtoPreconditions.CheckNotNull(value, "value");
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasLeadingComments => leadingComments_ != null;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public string TrailingComments
				{
					get
					{
						return trailingComments_ ?? TrailingCommentsDefaultValue;
					}
					set
					{
						trailingComments_ = ProtoPreconditions.CheckNotNull(value, "value");
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasTrailingComments => trailingComments_ != null;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public RepeatedField<string> LeadingDetachedComments => leadingDetachedComments_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Location()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Location(Location other)
					: this()
				{
					path_ = other.path_.Clone();
					span_ = other.span_.Clone();
					leadingComments_ = other.leadingComments_;
					trailingComments_ = other.trailingComments_;
					leadingDetachedComments_ = other.leadingDetachedComments_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Location Clone()
				{
					return new Location(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearLeadingComments()
				{
					leadingComments_ = null;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearTrailingComments()
				{
					trailingComments_ = null;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as Location);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(Location other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!path_.Equals(other.path_))
					{
						return false;
					}
					if (!span_.Equals(other.span_))
					{
						return false;
					}
					if (LeadingComments != other.LeadingComments)
					{
						return false;
					}
					if (TrailingComments != other.TrailingComments)
					{
						return false;
					}
					if (!leadingDetachedComments_.Equals(other.leadingDetachedComments_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= path_.GetHashCode();
					num ^= span_.GetHashCode();
					if (HasLeadingComments)
					{
						num ^= LeadingComments.GetHashCode();
					}
					if (HasTrailingComments)
					{
						num ^= TrailingComments.GetHashCode();
					}
					num ^= leadingDetachedComments_.GetHashCode();
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					path_.WriteTo(ref output, _repeated_path_codec);
					span_.WriteTo(ref output, _repeated_span_codec);
					if (HasLeadingComments)
					{
						output.WriteRawTag(26);
						output.WriteString(LeadingComments);
					}
					if (HasTrailingComments)
					{
						output.WriteRawTag(34);
						output.WriteString(TrailingComments);
					}
					leadingDetachedComments_.WriteTo(ref output, _repeated_leadingDetachedComments_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					num += path_.CalculateSize(_repeated_path_codec);
					num += span_.CalculateSize(_repeated_span_codec);
					if (HasLeadingComments)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(LeadingComments);
					}
					if (HasTrailingComments)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(TrailingComments);
					}
					num += leadingDetachedComments_.CalculateSize(_repeated_leadingDetachedComments_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(Location other)
				{
					if (other != null)
					{
						path_.Add(other.path_);
						span_.Add(other.span_);
						if (other.HasLeadingComments)
						{
							LeadingComments = other.LeadingComments;
						}
						if (other.HasTrailingComments)
						{
							TrailingComments = other.TrailingComments;
						}
						leadingDetachedComments_.Add(other.leadingDetachedComments_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 8u:
						case 10u:
							path_.AddEntriesFrom(ref input, _repeated_path_codec);
							break;
						case 16u:
						case 18u:
							span_.AddEntriesFrom(ref input, _repeated_span_codec);
							break;
						case 26u:
							LeadingComments = input.ReadString();
							break;
						case 34u:
							TrailingComments = input.ReadString();
							break;
						case 50u:
							leadingDetachedComments_.AddEntriesFrom(ref input, _repeated_leadingDetachedComments_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<SourceCodeInfo> _parser = new MessageParser<SourceCodeInfo>(() => new SourceCodeInfo());

		private UnknownFieldSet _unknownFields;

		public const int LocationFieldNumber = 1;

		private static readonly FieldCodec<Types.Location> _repeated_location_codec = FieldCodec.ForMessage(10u, Types.Location.Parser);

		private readonly RepeatedField<Types.Location> location_ = new RepeatedField<Types.Location>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<SourceCodeInfo> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[19];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.Location> Location => location_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceCodeInfo()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceCodeInfo(SourceCodeInfo other)
			: this()
		{
			location_ = other.location_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public SourceCodeInfo Clone()
		{
			return new SourceCodeInfo(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as SourceCodeInfo);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(SourceCodeInfo other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!location_.Equals(other.location_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= location_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			location_.WriteTo(ref output, _repeated_location_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += location_.CalculateSize(_repeated_location_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(SourceCodeInfo other)
		{
			if (other != null)
			{
				location_.Add(other.location_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					location_.AddEntriesFrom(ref input, _repeated_location_codec);
				}
			}
		}
	}
	public sealed class GeneratedCodeInfo : IMessage<GeneratedCodeInfo>, IMessage, IEquatable<GeneratedCodeInfo>, IDeepCloneable<GeneratedCodeInfo>, IBufferMessage
	{
		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static class Types
		{
			public sealed class Annotation : IMessage<Annotation>, IMessage, IEquatable<Annotation>, IDeepCloneable<Annotation>, IBufferMessage
			{
				private static readonly MessageParser<Annotation> _parser = new MessageParser<Annotation>(() => new Annotation());

				private UnknownFieldSet _unknownFields;

				private int _hasBits0;

				public const int PathFieldNumber = 1;

				private static readonly FieldCodec<int> _repeated_path_codec = FieldCodec.ForInt32(10u);

				private readonly RepeatedField<int> path_ = new RepeatedField<int>();

				public const int SourceFileFieldNumber = 2;

				private static readonly string SourceFileDefaultValue = "";

				private string sourceFile_;

				public const int BeginFieldNumber = 3;

				private static readonly int BeginDefaultValue = 0;

				private int begin_;

				public const int EndFieldNumber = 4;

				private static readonly int EndDefaultValue = 0;

				private int end_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageParser<Annotation> Parser => _parser;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public static MessageDescriptor Descriptor => GeneratedCodeInfo.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public RepeatedField<int> Path => path_;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public string SourceFile
				{
					get
					{
						return sourceFile_ ?? SourceFileDefaultValue;
					}
					set
					{
						sourceFile_ = ProtoPreconditions.CheckNotNull(value, "value");
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasSourceFile => sourceFile_ != null;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int Begin
				{
					get
					{
						if ((_hasBits0 & 1) != 0)
						{
							return begin_;
						}
						return BeginDefaultValue;
					}
					set
					{
						_hasBits0 |= 1;
						begin_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasBegin => (_hasBits0 & 1) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int End
				{
					get
					{
						if ((_hasBits0 & 2) != 0)
						{
							return end_;
						}
						return EndDefaultValue;
					}
					set
					{
						_hasBits0 |= 2;
						end_ = value;
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool HasEnd => (_hasBits0 & 2) != 0;

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Annotation()
				{
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Annotation(Annotation other)
					: this()
				{
					_hasBits0 = other._hasBits0;
					path_ = other.path_.Clone();
					sourceFile_ = other.sourceFile_;
					begin_ = other.begin_;
					end_ = other.end_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public Annotation Clone()
				{
					return new Annotation(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearSourceFile()
				{
					sourceFile_ = null;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearBegin()
				{
					_hasBits0 &= -2;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void ClearEnd()
				{
					_hasBits0 &= -3;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override bool Equals(object other)
				{
					return Equals(other as Annotation);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public bool Equals(Annotation other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!path_.Equals(other.path_))
					{
						return false;
					}
					if (SourceFile != other.SourceFile)
					{
						return false;
					}
					if (Begin != other.Begin)
					{
						return false;
					}
					if (End != other.End)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= path_.GetHashCode();
					if (HasSourceFile)
					{
						num ^= SourceFile.GetHashCode();
					}
					if (HasBegin)
					{
						num ^= Begin.GetHashCode();
					}
					if (HasEnd)
					{
						num ^= End.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= _unknownFields.GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void WriteTo(CodedOutputStream output)
				{
					output.WriteRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalWriteTo(ref WriteContext output)
				{
					path_.WriteTo(ref output, _repeated_path_codec);
					if (HasSourceFile)
					{
						output.WriteRawTag(18);
						output.WriteString(SourceFile);
					}
					if (HasBegin)
					{
						output.WriteRawTag(24);
						output.WriteInt32(Begin);
					}
					if (HasEnd)
					{
						output.WriteRawTag(32);
						output.WriteInt32(End);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(ref output);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public int CalculateSize()
				{
					int num = 0;
					num += path_.CalculateSize(_repeated_path_codec);
					if (HasSourceFile)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(SourceFile);
					}
					if (HasBegin)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Begin);
					}
					if (HasEnd)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(End);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(Annotation other)
				{
					if (other != null)
					{
						path_.Add(other.path_);
						if (other.HasSourceFile)
						{
							SourceFile = other.SourceFile;
						}
						if (other.HasBegin)
						{
							Begin = other.Begin;
						}
						if (other.HasEnd)
						{
							End = other.End;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				public void MergeFrom(CodedInputStream input)
				{
					input.ReadRawMessage(this);
				}

				[DebuggerNonUserCode]
				[GeneratedCode("protoc", null)]
				void IBufferMessage.InternalMergeFrom(ref ParseContext input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
							break;
						case 8u:
						case 10u:
							path_.AddEntriesFrom(ref input, _repeated_path_codec);
							break;
						case 18u:
							SourceFile = input.ReadString();
							break;
						case 24u:
							Begin = input.ReadInt32();
							break;
						case 32u:
							End = input.ReadInt32();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<GeneratedCodeInfo> _parser = new MessageParser<GeneratedCodeInfo>(() => new GeneratedCodeInfo());

		private UnknownFieldSet _unknownFields;

		public const int AnnotationFieldNumber = 1;

		private static readonly FieldCodec<Types.Annotation> _repeated_annotation_codec = FieldCodec.ForMessage(10u, Types.Annotation.Parser);

		private readonly RepeatedField<Types.Annotation> annotation_ = new RepeatedField<Types.Annotation>();

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageParser<GeneratedCodeInfo> Parser => _parser;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public static MessageDescriptor Descriptor => DescriptorReflection.Descriptor.MessageTypes[20];

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public RepeatedField<Types.Annotation> Annotation => annotation_;

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public GeneratedCodeInfo()
		{
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public GeneratedCodeInfo(GeneratedCodeInfo other)
			: this()
		{
			annotation_ = other.annotation_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public GeneratedCodeInfo Clone()
		{
			return new GeneratedCodeInfo(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override bool Equals(object other)
		{
			return Equals(other as GeneratedCodeInfo);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public bool Equals(GeneratedCodeInfo other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!annotation_.Equals(other.annotation_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= annotation_.GetHashCode();
			if (_unknownFields != null)
			{
				num ^= _unknownFields.GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void WriteTo(CodedOutputStream output)
		{
			output.WriteRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalWriteTo(ref WriteContext output)
		{
			annotation_.WriteTo(ref output, _repeated_annotation_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(ref output);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public int CalculateSize()
		{
			int num = 0;
			num += annotation_.CalculateSize(_repeated_annotation_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(GeneratedCodeInfo other)
		{
			if (other != null)
			{
				annotation_.Add(other.annotation_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		public void MergeFrom(CodedInputStream input)
		{
			input.ReadRawMessage(this);
		}

		[DebuggerNonUserCode]
		[GeneratedCode("protoc", null)]
		void IBufferMessage.InternalMergeFrom(ref ParseContext input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
				}
				else
				{
					annotation_.AddEntriesFrom(ref input, _repeated_annotation_codec);
				}
			}
		}
	}
	public abstract class DescriptorBase : IDescriptor
	{
		public int Index { get; }

		public abstract string Name { get; }

		public string FullName { get; }

		public FileDescriptor File { get; }

		public DescriptorDeclaration Declaration => File.GetDeclaration(this);

		internal DescriptorBase(FileDescriptor file, string fullName, int index)
		{
			File = file;
			FullName = fullName;
			Index = index;
		}

		internal virtual IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
		{
			return null;
		}
	}
	public sealed class DescriptorDeclaration
	{
		public IDescriptor Descriptor { get; }

		public int StartLine { get; }

		public int StartColumn { get; }

		public int EndLine { get; }

		public int EndColumn { get; }

		public string LeadingComments { get; }

		public string TrailingComments { get; }

		public IReadOnlyList<string> LeadingDetachedComments { get; }

		private DescriptorDeclaration(IDescriptor descriptor, SourceCodeInfo.Types.Location location)
		{
			Descriptor = descriptor;
			bool flag = location.Span.Count == 4;
			StartLine = location.Span[0] + 1;
			StartColumn = location.Span[1] + 1;
			EndLine = (flag ? (location.Span[2] + 1) : StartLine);
			EndColumn = location.Span[flag ? 3 : 2] + 1;
			LeadingComments = location.LeadingComments;
			TrailingComments = location.TrailingComments;
			LeadingDetachedComments = new ReadOnlyCollection<string>(location.LeadingDetachedComments.ToList());
		}

		internal static DescriptorDeclaration FromProto(IDescriptor descriptor, SourceCodeInfo.Types.Location location)
		{
			return new DescriptorDeclaration(descriptor, location);
		}
	}
	internal sealed class DescriptorPool
	{
		private readonly IDictionary<string, IDescriptor> descriptorsByName = new Dictionary<string, IDescriptor>();

		private readonly IDictionary<ObjectIntPair<IDescriptor>, FieldDescriptor> fieldsByNumber = new Dictionary<ObjectIntPair<IDescriptor>, FieldDescriptor>();

		private readonly IDictionary<ObjectIntPair<IDescriptor>, EnumValueDescriptor> enumValuesByNumber = new Dictionary<ObjectIntPair<IDescriptor>, EnumValueDescriptor>();

		private readonly HashSet<FileDescriptor> dependencies;

		private static readonly Regex ValidationRegex = new Regex("^[_A-Za-z][_A-Za-z0-9]*$", FrameworkPortability.CompiledRegexWhereAvailable);

		internal DescriptorPool(IEnumerable<FileDescriptor> dependencyFiles)
		{
			dependencies = new HashSet<FileDescriptor>();
			foreach (FileDescriptor dependencyFile in dependencyFiles)
			{
				dependencies.Add(dependencyFile);
				ImportPublicDependencies(dependencyFile);
			}
			foreach (FileDescriptor dependencyFile2 in dependencyFiles)
			{
				AddPackage(dependencyFile2.Package, dependencyFile2);
			}
		}

		private void ImportPublicDependencies(FileDescriptor file)
		{
			foreach (FileDescriptor publicDependency in file.PublicDependencies)
			{
				if (dependencies.Add(publicDependency))
				{
					ImportPublicDependencies(publicDependency);
				}
			}
		}

		internal T FindSymbol<T>(string fullName) where T : class
		{
			descriptorsByName.TryGetValue(fullName, out var value);
			if (value is T result)
			{
				return result;
			}
			foreach (FileDescriptor dependency in dependencies)
			{
				dependency.DescriptorPool.descriptorsByName.TryGetValue(fullName, out value);
				if (value is T result2)
				{
					return result2;
				}
			}
			return null;
		}

		internal void AddPackage(string fullName, FileDescriptor file)
		{
			int num = fullName.LastIndexOf('.');
			string text;
			if (num != -1)
			{
				AddPackage(fullName.Substring(0, num), file);
				text = fullName.Substring(num + 1);
			}
			else
			{
				text = fullName;
			}
			if (descriptorsByName.TryGetValue(fullName, out var value) && !(value is PackageDescriptor))
			{
				throw new DescriptorValidationException(file, "\"" + text + "\" is already defined (as something other than a package) in file \"" + value.File.Name + "\".");
			}
			descriptorsByName[fullName] = new PackageDescriptor(text, fullName, file);
		}

		internal void AddSymbol(IDescriptor descriptor)
		{
			ValidateSymbolName(descriptor);
			string fullName = descriptor.FullName;
			if (descriptorsByName.TryGetValue(fullName, out var value))
			{
				int num = fullName.LastIndexOf('.');
				string description = ((descriptor.File != value.File) ? ("\"" + fullName + "\" is already defined in file \"" + value.File.Name + "\".") : ((num != -1) ? ("\"" + fullName.Substring(num + 1) + "\" is already defined in \"" + fullName.Substring(0, num) + "\".") : ("\"" + fullName + "\" is already defined.")));
				throw new DescriptorValidationException(descriptor, description);
			}
			descriptorsByName[fullName] = descriptor;
		}

		private static void ValidateSymbolName(IDescriptor descriptor)
		{
			if (descriptor.Name == "")
			{
				throw new DescriptorValidationException(descriptor, "Missing name.");
			}
			if (!ValidationRegex.IsMatch(descriptor.Name))
			{
				throw new DescriptorValidationException(descriptor, "\"" + descriptor.Name + "\" is not a valid identifier.");
			}
		}

		internal FieldDescriptor FindFieldByNumber(MessageDescriptor messageDescriptor, int number)
		{
			fieldsByNumber.TryGetValue(new ObjectIntPair<IDescriptor>(messageDescriptor, number), out var value);
			return value;
		}

		internal EnumValueDescriptor FindEnumValueByNumber(EnumDescriptor enumDescriptor, int number)
		{
			enumValuesByNumber.TryGetValue(new ObjectIntPair<IDescriptor>(enumDescriptor, number), out var value);
			return value;
		}

		internal void AddFieldByNumber(FieldDescriptor field)
		{
			ObjectIntPair<IDescriptor> key = new ObjectIntPair<IDescriptor>(field.Proto.HasExtendee ? field.ExtendeeType : field.ContainingType, field.FieldNumber);
			if (fieldsByNumber.TryGetValue(key, out var value))
			{
				throw new DescriptorValidationException(field, "Field number " + field.FieldNumber + "has already been used in \"" + field.ContainingType.FullName + "\" by field \"" + value.Name + "\".");
			}
			fieldsByNumber[key] = field;
		}

		internal void AddEnumValueByNumber(EnumValueDescriptor enumValue)
		{
			ObjectIntPair<IDescriptor> key = new ObjectIntPair<IDescriptor>(enumValue.EnumDescriptor, enumValue.Number);
			if (!enumValuesByNumber.ContainsKey(key))
			{
				enumValuesByNumber[key] = enumValue;
			}
		}

		internal IDescriptor LookupSymbol(string name, IDescriptor relativeTo)
		{
			IDescriptor descriptor;
			if (name.StartsWith("."))
			{
				descriptor = FindSymbol<IDescriptor>(name.Substring(1));
			}
			else
			{
				int num = name.IndexOf('.');
				string value = ((num == -1) ? name : name.Substring(0, num));
				StringBuilder stringBuilder = new StringBuilder(relativeTo.FullName);
				while (true)
				{
					int num2 = stringBuilder.ToString().LastIndexOf(".");
					if (num2 == -1)
					{
						descriptor = FindSymbol<IDescriptor>(name);
						break;
					}
					stringBuilder.Length = num2 + 1;
					stringBuilder.Append(value);
					descriptor = FindSymbol<IDescriptor>(stringBuilder.ToString());
					if (descriptor != null)
					{
						if (num != -1)
						{
							stringBuilder.Length = num2 + 1;
							stringBuilder.Append(name);
							descriptor = FindSymbol<IDescriptor>(stringBuilder.ToString());
						}
						break;
					}
					stringBuilder.Length = num2;
				}
			}
			if (descriptor == null)
			{
				throw new DescriptorValidationException(relativeTo, "\"" + name + "\" is not defined.");
			}
			return descriptor;
		}
	}
	internal static class DescriptorUtil
	{
		internal delegate TOutput IndexedConverter<TInput, TOutput>(TInput element, int index);

		internal static IList<TOutput> ConvertAndMakeReadOnly<TInput, TOutput>(IList<TInput> input, IndexedConverter<TInput, TOutput> converter)
		{
			TOutput[] array = new TOutput[input.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = converter(input[i], i);
			}
			return new ReadOnlyCollection<TOutput>(array);
		}
	}
	public sealed class DescriptorValidationException : Exception
	{
		private readonly string name;

		private readonly string description;

		public string ProblemSymbolName => name;

		public string Description => description;

		internal DescriptorValidationException(IDescriptor problemDescriptor, string description)
			: base(problemDescriptor.FullName + ": " + description)
		{
			name = problemDescriptor.FullName;
			this.description = description;
		}

		internal DescriptorValidationException(IDescriptor problemDescriptor, string description, Exception cause)
			: base(problemDescriptor.FullName + ": " + description, cause)
		{
			name = problemDescriptor.FullName;
			this.description = description;
		}
	}
	public sealed class EnumDescriptor : DescriptorBase
	{
		private readonly EnumDescriptorProto proto;

		private readonly MessageDescriptor containingType;

		private readonly IList<EnumValueDescriptor> values;

		private readonly System.Type clrType;

		internal EnumDescriptorProto Proto => proto;

		public override string Name => proto.Name;

		public System.Type ClrType => clrType;

		public MessageDescriptor ContainingType => containingType;

		public IList<EnumValueDescriptor> Values => values;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal EnumDescriptor(EnumDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index, System.Type clrType)
			: base(file, file.ComputeFullName(parent, proto.Name), index)
		{
			EnumDescriptor parent2 = this;
			this.proto = proto;
			this.clrType = clrType;
			containingType = parent;
			if (proto.Value.Count == 0)
			{
				throw new DescriptorValidationException(this, "Enums must contain at least one value.");
			}
			values = DescriptorUtil.ConvertAndMakeReadOnly(proto.Value, (EnumValueDescriptorProto value, int i) => new EnumValueDescriptor(value, file, parent2, i));
			base.File.DescriptorPool.AddSymbol(this);
		}

		public EnumDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
		{
			if (fieldNumber == 2)
			{
				return (IReadOnlyList<DescriptorBase>)Values;
			}
			return null;
		}

		public EnumValueDescriptor FindValueByNumber(int number)
		{
			return base.File.DescriptorPool.FindEnumValueByNumber(this, number);
		}

		public EnumValueDescriptor FindValueByName(string name)
		{
			return base.File.DescriptorPool.FindSymbol<EnumValueDescriptor>(base.FullName + "." + name);
		}

		public EnumOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<EnumOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<EnumOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}
	}
	public sealed class EnumValueDescriptor : DescriptorBase
	{
		private readonly EnumDescriptor enumDescriptor;

		private readonly EnumValueDescriptorProto proto;

		internal EnumValueDescriptorProto Proto => proto;

		public override string Name => proto.Name;

		public int Number => Proto.Number;

		public EnumDescriptor EnumDescriptor => enumDescriptor;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal EnumValueDescriptor(EnumValueDescriptorProto proto, FileDescriptor file, EnumDescriptor parent, int index)
			: base(file, parent.FullName + "." + proto.Name, index)
		{
			this.proto = proto;
			enumDescriptor = parent;
			file.DescriptorPool.AddSymbol(this);
			file.DescriptorPool.AddEnumValueByNumber(this);
		}

		public EnumValueDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		public EnumValueOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<EnumValueOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<EnumValueOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}
	}
	internal sealed class ExtensionAccessor : IFieldAccessor
	{
		private readonly Extension extension;

		private readonly ReflectionUtil.IExtensionReflectionHelper helper;

		public FieldDescriptor Descriptor { get; }

		internal ExtensionAccessor(FieldDescriptor descriptor)
		{
			Descriptor = descriptor;
			extension = descriptor.Extension;
			helper = ReflectionUtil.CreateExtensionHelper(extension);
		}

		public void Clear(IMessage message)
		{
			helper.ClearExtension(message);
		}

		public bool HasValue(IMessage message)
		{
			return helper.HasExtension(message);
		}

		public object GetValue(IMessage message)
		{
			return helper.GetExtension(message);
		}

		public void SetValue(IMessage message, object value)
		{
			helper.SetExtension(message, value);
		}
	}
	public sealed class ExtensionCollection
	{
		private IDictionary<MessageDescriptor, IList<FieldDescriptor>> extensionsByTypeInDeclarationOrder;

		private IDictionary<MessageDescriptor, IList<FieldDescriptor>> extensionsByTypeInNumberOrder;

		public IList<FieldDescriptor> UnorderedExtensions { get; }

		internal ExtensionCollection(FileDescriptor file, Extension[] extensions)
		{
			UnorderedExtensions = DescriptorUtil.ConvertAndMakeReadOnly(file.Proto.Extension, delegate(FieldDescriptorProto extension, int i)
			{
				Extension[] array = extensions;
				if (array == null || array.Length != 0)
				{
					FileDescriptor file2 = file;
					Extension[] array2 = extensions;
					return new FieldDescriptor(extension, file2, null, i, null, (array2 != null) ? array2[i] : null);
				}
				return new FieldDescriptor(extension, file, null, i, null, null);
			});
		}

		internal ExtensionCollection(MessageDescriptor message, Extension[] extensions)
		{
			UnorderedExtensions = DescriptorUtil.ConvertAndMakeReadOnly(message.Proto.Extension, delegate(FieldDescriptorProto extension, int i)
			{
				Extension[] array = extensions;
				if (array == null || array.Length != 0)
				{
					FileDescriptor file = message.File;
					MessageDescriptor parent = message;
					Extension[] array2 = extensions;
					return new FieldDescriptor(extension, file, parent, i, null, (array2 != null) ? array2[i] : null);
				}
				return new FieldDescriptor(extension, message.File, message, i, null, null);
			});
		}

		public IList<FieldDescriptor> GetExtensionsInDeclarationOrder(MessageDescriptor descriptor)
		{
			return extensionsByTypeInDeclarationOrder[descriptor];
		}

		public IList<FieldDescriptor> GetExtensionsInNumberOrder(MessageDescriptor descriptor)
		{
			return extensionsByTypeInNumberOrder[descriptor];
		}

		internal void CrossLink()
		{
			Dictionary<MessageDescriptor, IList<FieldDescriptor>> dictionary = new Dictionary<MessageDescriptor, IList<FieldDescriptor>>();
			foreach (FieldDescriptor unorderedExtension in UnorderedExtensions)
			{
				unorderedExtension.CrossLink();
				if (!dictionary.TryGetValue(unorderedExtension.ExtendeeType, out var value))
				{
					value = new List<FieldDescriptor>();
					dictionary.Add(unorderedExtension.ExtendeeType, value);
				}
				value.Add(unorderedExtension);
			}
			extensionsByTypeInDeclarationOrder = ((IEnumerable<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>>)dictionary).ToDictionary((Func<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>, MessageDescriptor>)((KeyValuePair<MessageDescriptor, IList<FieldDescriptor>> kvp) => kvp.Key), (Func<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>, IList<FieldDescriptor>>)((KeyValuePair<MessageDescriptor, IList<FieldDescriptor>> kvp) => new ReadOnlyCollection<FieldDescriptor>(kvp.Value)));
			extensionsByTypeInNumberOrder = ((IEnumerable<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>>)dictionary).ToDictionary((Func<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>, MessageDescriptor>)((KeyValuePair<MessageDescriptor, IList<FieldDescriptor>> kvp) => kvp.Key), (Func<KeyValuePair<MessageDescriptor, IList<FieldDescriptor>>, IList<FieldDescriptor>>)((KeyValuePair<MessageDescriptor, IList<FieldDescriptor>> kvp) => new ReadOnlyCollection<FieldDescriptor>(kvp.Value.OrderBy((FieldDescriptor field) => field.FieldNumber).ToArray())));
		}
	}
	internal abstract class FieldAccessorBase : IFieldAccessor
	{
		private readonly Func<IMessage, object> getValueDelegate;

		private readonly FieldDescriptor descriptor;

		public FieldDescriptor Descriptor => descriptor;

		internal FieldAccessorBase(PropertyInfo property, FieldDescriptor descriptor)
		{
			this.descriptor = descriptor;
			getValueDelegate = ReflectionUtil.CreateFuncIMessageObject(property.GetGetMethod());
		}

		public object GetValue(IMessage message)
		{
			return getValueDelegate(message);
		}

		public abstract bool HasValue(IMessage message);

		public abstract void Clear(IMessage message);

		public abstract void SetValue(IMessage message, object value);
	}
	public sealed class FieldDescriptor : DescriptorBase, IComparable<FieldDescriptor>
	{
		private EnumDescriptor enumType;

		private MessageDescriptor extendeeType;

		private MessageDescriptor messageType;

		private FieldType fieldType;

		private IFieldAccessor accessor;

		public MessageDescriptor ContainingType { get; }

		public OneofDescriptor ContainingOneof { get; }

		public OneofDescriptor RealContainingOneof
		{
			get
			{
				OneofDescriptor containingOneof = ContainingOneof;
				if (containingOneof == null || containingOneof.IsSynthetic)
				{
					return null;
				}
				return ContainingOneof;
			}
		}

		public string JsonName { get; }

		public string PropertyName { get; }

		public bool HasPresence
		{
			get
			{
				if (Extension == null)
				{
					if (!IsRepeated)
					{
						if (!IsMap)
						{
							if (FieldType != FieldType.Message)
							{
								if (ContainingOneof == null)
								{
									return base.File.Syntax == Syntax.Proto2;
								}
								return true;
							}
							return true;
						}
						return false;
					}
					return false;
				}
				return !Extension.IsRepeated;
			}
		}

		internal FieldDescriptorProto Proto { get; }

		public Extension Extension { get; }

		public override string Name => Proto.Name;

		public IFieldAccessor Accessor => accessor;

		public bool IsRepeated => Proto.Label == FieldDescriptorProto.Types.Label.Repeated;

		public bool IsRequired => Proto.Label == FieldDescriptorProto.Types.Label.Required;

		public bool IsMap
		{
			get
			{
				if (fieldType == FieldType.Message && messageType.Proto.Options != null)
				{
					return messageType.Proto.Options.MapEntry;
				}
				return false;
			}
		}

		public bool IsPacked
		{
			get
			{
				if (base.File.Syntax != Syntax.Proto3)
				{
					return Proto.Options?.Packed ?? false;
				}
				if (Proto.Options != null && Proto.Options.HasPacked)
				{
					return Proto.Options.Packed;
				}
				return true;
			}
		}

		public bool IsExtension => Proto.HasExtendee;

		public FieldType FieldType => fieldType;

		public int FieldNumber => Proto.Number;

		public EnumDescriptor EnumType
		{
			get
			{
				if (fieldType != FieldType.Enum)
				{
					throw new InvalidOperationException("EnumType is only valid for enum fields.");
				}
				return enumType;
			}
		}

		public MessageDescriptor MessageType
		{
			get
			{
				if (fieldType != FieldType.Message && fieldType != FieldType.Group)
				{
					throw new InvalidOperationException("MessageType is only valid for message or group fields.");
				}
				return messageType;
			}
		}

		public MessageDescriptor ExtendeeType
		{
			get
			{
				if (!Proto.HasExtendee)
				{
					throw new InvalidOperationException("ExtendeeType is only valid for extension fields.");
				}
				return extendeeType;
			}
		}

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		public FieldDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index, string propertyName, Extension extension)
			: base(file, file.ComputeFullName(parent, proto.Name), index)
		{
			Proto = proto;
			if (proto.Type != 0)
			{
				fieldType = GetFieldTypeFromProtoType(proto.Type);
			}
			if (FieldNumber <= 0)
			{
				throw new DescriptorValidationException(this, "Field numbers must be positive integers.");
			}
			ContainingType = parent;
			if (proto.HasOneofIndex)
			{
				if (proto.OneofIndex < 0 || proto.OneofIndex >= parent.Proto.OneofDecl.Count)
				{
					throw new DescriptorValidationException(this, "FieldDescriptorProto.oneof_index is out of range for type " + parent.Name);
				}
				ContainingOneof = parent.Oneofs[proto.OneofIndex];
			}
			file.DescriptorPool.AddSymbol(this);
			PropertyName = propertyName;
			Extension = extension;
			JsonName = ((Proto.JsonName == "") ? JsonFormatter.ToJsonName(Proto.Name) : Proto.JsonName);
		}

		private static FieldType GetFieldTypeFromProtoType(FieldDescriptorProto.Types.Type type)
		{
			return type switch
			{
				FieldDescriptorProto.Types.Type.Double => FieldType.Double, 
				FieldDescriptorProto.Types.Type.Float => FieldType.Float, 
				FieldDescriptorProto.Types.Type.Int64 => FieldType.Int64, 
				FieldDescriptorProto.Types.Type.Uint64 => FieldType.UInt64, 
				FieldDescriptorProto.Types.Type.Int32 => FieldType.Int32, 
				FieldDescriptorProto.Types.Type.Fixed64 => FieldType.Fixed64, 
				FieldDescriptorProto.Types.Type.Fixed32 => FieldType.Fixed32, 
				FieldDescriptorProto.Types.Type.Bool => FieldType.Bool, 
				FieldDescriptorProto.Types.Type.String => FieldType.String, 
				FieldDescriptorProto.Types.Type.Group => FieldType.Group, 
				FieldDescriptorProto.Types.Type.Message => FieldType.Message, 
				FieldDescriptorProto.Types.Type.Bytes => FieldType.Bytes, 
				FieldDescriptorProto.Types.Type.Uint32 => FieldType.UInt32, 
				FieldDescriptorProto.Types.Type.Enum => FieldType.Enum, 
				FieldDescriptorProto.Types.Type.Sfixed32 => FieldType.SFixed32, 
				FieldDescriptorProto.Types.Type.Sfixed64 => FieldType.SFixed64, 
				FieldDescriptorProto.Types.Type.Sint32 => FieldType.SInt32, 
				FieldDescriptorProto.Types.Type.Sint64 => FieldType.SInt64, 
				_ => throw new ArgumentException("Invalid type specified"), 
			};
		}

		public int CompareTo(FieldDescriptor other)
		{
			if (other.ContainingType != ContainingType)
			{
				throw new ArgumentException("FieldDescriptors can only be compared to other FieldDescriptors for fields of the same message type.");
			}
			return FieldNumber - other.FieldNumber;
		}

		public FieldOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<FieldOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<FieldOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		internal void CrossLink()
		{
			if (Proto.HasTypeName)
			{
				IDescriptor descriptor = base.File.DescriptorPool.LookupSymbol(Proto.TypeName, this);
				if (Proto.HasType)
				{
					if (descriptor is MessageDescriptor)
					{
						fieldType = FieldType.Message;
					}
					else
					{
						if (!(descriptor is EnumDescriptor))
						{
							throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a type.");
						}
						fieldType = FieldType.Enum;
					}
				}
				if (fieldType == FieldType.Message || fieldType == FieldType.Group)
				{
					if (!(descriptor is MessageDescriptor))
					{
						throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a message type.");
					}
					messageType = (MessageDescriptor)descriptor;
					if (Proto.HasDefaultValue)
					{
						throw new DescriptorValidationException(this, "Messages can't have default values.");
					}
				}
				else
				{
					if (fieldType != FieldType.Enum)
					{
						throw new DescriptorValidationException(this, "Field with primitive type has type_name.");
					}
					if (!(descriptor is EnumDescriptor))
					{
						throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not an enum type.");
					}
					enumType = (EnumDescriptor)descriptor;
				}
			}
			else if (fieldType == FieldType.Message || fieldType == FieldType.Enum)
			{
				throw new DescriptorValidationException(this, "Field with message or enum type missing type_name.");
			}
			if (Proto.HasExtendee)
			{
				extendeeType = base.File.DescriptorPool.LookupSymbol(Proto.Extendee, this) as MessageDescriptor;
			}
			base.File.DescriptorPool.AddFieldByNumber(this);
			if (ContainingType != null && ContainingType.Proto.Options != null && ContainingType.Proto.Options.MessageSetWireFormat)
			{
				throw new DescriptorValidationException(this, "MessageSet format is not supported.");
			}
			accessor = CreateAccessor();
		}

		private IFieldAccessor CreateAccessor()
		{
			if (Extension != null)
			{
				return new ExtensionAccessor(this);
			}
			if (PropertyName == null)
			{
				return null;
			}
			PropertyInfo property = ContainingType.ClrType.GetProperty(PropertyName);
			if (property == null)
			{
				throw new DescriptorValidationException(this, $"Property {PropertyName} not found in {ContainingType.ClrType}");
			}
			if (!IsMap)
			{
				if (!IsRepeated)
				{
					return new SingleFieldAccessor(ContainingType.ClrType, property, this);
				}
				return new RepeatedFieldAccessor(property, this);
			}
			return new MapFieldAccessor(property, this);
		}
	}
	public enum FieldType
	{
		Double,
		Float,
		Int64,
		UInt64,
		Int32,
		Fixed64,
		Fixed32,
		Bool,
		String,
		Group,
		Message,
		Bytes,
		UInt32,
		SFixed32,
		SFixed64,
		SInt32,
		SInt64,
		Enum
	}
	public enum Syntax
	{
		Proto2,
		Proto3,
		Unknown
	}
	public sealed class FileDescriptor : IDescriptor
	{
		private readonly Lazy<Dictionary<IDescriptor, DescriptorDeclaration>> declarations;

		internal FileDescriptorProto Proto { get; }

		public Syntax Syntax { get; }

		public string Name => Proto.Name;

		public string Package => Proto.Package;

		public IList<MessageDescriptor> MessageTypes { get; }

		public IList<EnumDescriptor> EnumTypes { get; }

		public IList<ServiceDescriptor> Services { get; }

		public ExtensionCollection Extensions { get; }

		public IList<FileDescriptor> Dependencies { get; }

		public IList<FileDescriptor> PublicDependencies { get; }

		public ByteString SerializedData { get; }

		string IDescriptor.FullName => Name;

		FileDescriptor IDescriptor.File => this;

		internal DescriptorPool DescriptorPool { get; }

		public static FileDescriptor DescriptorProtoFileDescriptor => DescriptorReflection.Descriptor;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		static FileDescriptor()
		{
			ForceReflectionInitialization<Syntax>();
			ForceReflectionInitialization<NullValue>();
			ForceReflectionInitialization<Field.Types.Cardinality>();
			ForceReflectionInitialization<Field.Types.Kind>();
			ForceReflectionInitialization<Value.KindOneofCase>();
		}

		private FileDescriptor(ByteString descriptorData, FileDescriptorProto proto, IEnumerable<FileDescriptor> dependencies, DescriptorPool pool, bool allowUnknownDependencies, GeneratedClrTypeInfo generatedCodeInfo)
		{
			FileDescriptor fileDescriptor = this;
			SerializedData = descriptorData;
			DescriptorPool = pool;
			Proto = proto;
			Dependencies = new ReadOnlyCollection<FileDescriptor>(dependencies.ToList());
			PublicDependencies = DeterminePublicDependencies(this, proto, dependencies, allowUnknownDependencies);
			pool.AddPackage(Package, this);
			MessageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageType, delegate(DescriptorProto message, int index)
			{
				FileDescriptor file = fileDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new MessageDescriptor(message, file, null, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.NestedTypes[index] : null);
			});
			EnumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumType, delegate(EnumDescriptorProto enumType, int index)
			{
				FileDescriptor file = fileDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new EnumDescriptor(enumType, file, null, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.NestedEnums[index] : null);
			});
			Services = DescriptorUtil.ConvertAndMakeReadOnly(proto.Service, (ServiceDescriptorProto service, int index) => new ServiceDescriptor(service, fileDescriptor, index));
			Extensions = new ExtensionCollection(this, generatedCodeInfo?.Extensions);
			declarations = new Lazy<Dictionary<IDescriptor, DescriptorDeclaration>>(CreateDeclarationMap, LazyThreadSafetyMode.ExecutionAndPublication);
			if (!proto.HasSyntax || proto.Syntax == "proto2")
			{
				Syntax = Syntax.Proto2;
			}
			else if (proto.Syntax == "proto3")
			{
				Syntax = Syntax.Proto3;
			}
			else
			{
				Syntax = Syntax.Unknown;
			}
		}

		private Dictionary<IDescriptor, DescriptorDeclaration> CreateDeclarationMap()
		{
			Dictionary<IDescriptor, DescriptorDeclaration> dictionary = new Dictionary<IDescriptor, DescriptorDeclaration>();
			IEnumerable<SourceCodeInfo.Types.Location> enumerable = Proto.SourceCodeInfo?.Location;
			foreach (SourceCodeInfo.Types.Location item in enumerable ?? Enumerable.Empty<SourceCodeInfo.Types.Location>())
			{
				IDescriptor descriptor = FindDescriptorForPath(item.Path);
				if (descriptor != null)
				{
					dictionary[descriptor] = DescriptorDeclaration.FromProto(descriptor, item);
				}
			}
			return dictionary;
		}

		private IDescriptor FindDescriptorForPath(IList<int> path)
		{
			if (path.Count == 0 || (path.Count & 1) != 0)
			{
				return null;
			}
			IReadOnlyList<DescriptorBase> nestedDescriptorListForField = GetNestedDescriptorListForField(path[0]);
			DescriptorBase descriptorFromList = GetDescriptorFromList(nestedDescriptorListForField, path[1]);
			int num = 2;
			while (descriptorFromList != null && num < path.Count)
			{
				IReadOnlyList<DescriptorBase> nestedDescriptorListForField2 = descriptorFromList.GetNestedDescriptorListForField(path[num]);
				descriptorFromList = GetDescriptorFromList(nestedDescriptorListForField2, path[num + 1]);
				num += 2;
			}
			return descriptorFromList;
		}

		private DescriptorBase GetDescriptorFromList(IReadOnlyList<DescriptorBase> list, int index)
		{
			if (list == null)
			{
				return null;
			}
			if (index < 0 || index >= list.Count)
			{
				throw new InvalidProtocolBufferException("Invalid descriptor location path: index out of range");
			}
			return list[index];
		}

		private IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
		{
			return fieldNumber switch
			{
				6 => (IReadOnlyList<DescriptorBase>)Services, 
				4 => (IReadOnlyList<DescriptorBase>)MessageTypes, 
				5 => (IReadOnlyList<DescriptorBase>)EnumTypes, 
				_ => null, 
			};
		}

		internal DescriptorDeclaration GetDeclaration(IDescriptor descriptor)
		{
			declarations.Value.TryGetValue(descriptor, out var value);
			return value;
		}

		internal string ComputeFullName(MessageDescriptor parent, string name)
		{
			if (parent != null)
			{
				return parent.FullName + "." + name;
			}
			if (Package.Length > 0)
			{
				return Package + "." + name;
			}
			return name;
		}

		private static IList<FileDescriptor> DeterminePublicDependencies(FileDescriptor @this, FileDescriptorProto proto, IEnumerable<FileDescriptor> dependencies, bool allowUnknownDependencies)
		{
			Dictionary<string, FileDescriptor> dictionary = dependencies.ToDictionary((FileDescriptor file) => file.Name);
			List<FileDescriptor> list = new List<FileDescriptor>();
			for (int num = 0; num < proto.PublicDependency.Count; num++)
			{
				int num2 = proto.PublicDependency[num];
				if (num2 < 0 || num2 >= proto.Dependency.Count)
				{
					throw new DescriptorValidationException(@this, "Invalid public dependency index.");
				}
				string text = proto.Dependency[num2];
				if (!dictionary.TryGetValue(text, out var value))
				{
					if (!allowUnknownDependencies)
					{
						throw new DescriptorValidationException(@this, "Invalid public dependency: " + text);
					}
				}
				else
				{
					list.Add(value);
				}
			}
			return new ReadOnlyCollection<FileDescriptor>(list);
		}

		public FileDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		public T FindTypeByName<T>(string name) where T : class, IDescriptor
		{
			if (name.IndexOf('.') != -1)
			{
				return null;
			}
			if (Package.Length > 0)
			{
				name = Package + "." + name;
			}
			T val = DescriptorPool.FindSymbol<T>(name);
			if (val != null && val.File == this)
			{
				return val;
			}
			return null;
		}

		private static FileDescriptor BuildFrom(ByteString descriptorData, FileDescriptorProto proto, FileDescriptor[] dependencies, bool allowUnknownDependencies, GeneratedClrTypeInfo generatedCodeInfo)
		{
			if (dependencies == null)
			{
				dependencies = new FileDescriptor[0];
			}
			DescriptorPool pool = new DescriptorPool(dependencies);
			FileDescriptor fileDescriptor = new FileDescriptor(descriptorData, proto, dependencies, pool, allowUnknownDependencies, generatedCodeInfo);
			if (dependencies.Length != proto.Dependency.Count)
			{
				throw new DescriptorValidationException(fileDescriptor, "Dependencies passed to FileDescriptor.BuildFrom() don't match those listed in the FileDescriptorProto.");
			}
			fileDescriptor.CrossLink();
			return fileDescriptor;
		}

		private void CrossLink()
		{
			foreach (MessageDescriptor messageType in MessageTypes)
			{
				messageType.CrossLink();
			}
			foreach (ServiceDescriptor service in Services)
			{
				service.CrossLink();
			}
			Extensions.CrossLink();
		}

		public static FileDescriptor FromGeneratedCode(byte[] descriptorData, FileDescriptor[] dependencies, GeneratedClrTypeInfo generatedCodeInfo)
		{
			ExtensionRegistry extensionRegistry = new ExtensionRegistry();
			extensionRegistry.AddRange(GetAllExtensions(dependencies, generatedCodeInfo));
			FileDescriptorProto fileDescriptorProto;
			try
			{
				fileDescriptorProto = FileDescriptorProto.Parser.WithExtensionRegistry(extensionRegistry).ParseFrom(descriptorData);
			}
			catch (InvalidProtocolBufferException innerException)
			{
				throw new ArgumentException("Failed to parse protocol buffer descriptor for generated code.", innerException);
			}
			try
			{
				return BuildFrom(ByteString.CopyFrom(descriptorData), fileDescriptorProto, dependencies, allowUnknownDependencies: true, generatedCodeInfo);
			}
			catch (DescriptorValidationException innerException2)
			{
				throw new ArgumentException("Invalid embedded descriptor for \"" + fileDescriptorProto.Name + "\".", innerException2);
			}
		}

		private static IEnumerable<Extension> GetAllExtensions(FileDescriptor[] dependencies, GeneratedClrTypeInfo generatedInfo)
		{
			return dependencies.SelectMany(GetAllDependedExtensions).Distinct(ExtensionRegistry.ExtensionComparer.Instance).Concat(GetAllGeneratedExtensions(generatedInfo));
		}

		private static IEnumerable<Extension> GetAllGeneratedExtensions(GeneratedClrTypeInfo generated)
		{
			return generated.Extensions.Concat(generated.NestedTypes.Where((GeneratedClrTypeInfo t) => t != null).SelectMany(GetAllGeneratedExtensions));
		}

		private static IEnumerable<Extension> GetAllDependedExtensions(FileDescriptor descriptor)
		{
			return (from s in descriptor.Extensions.UnorderedExtensions
				select s.Extension into e
				where e != null
				select e).Concat(descriptor.Dependencies.Concat(descriptor.PublicDependencies).SelectMany(GetAllDependedExtensions)).Concat(descriptor.MessageTypes.SelectMany(GetAllDependedExtensionsFromMessage));
		}

		private static IEnumerable<Extension> GetAllDependedExtensionsFromMessage(MessageDescriptor descriptor)
		{
			return (from s in descriptor.Extensions.UnorderedExtensions
				select s.Extension into e
				where e != null
				select e).Concat(descriptor.NestedTypes.SelectMany(GetAllDependedExtensionsFromMessage));
		}

		public static IReadOnlyList<FileDescriptor> BuildFromByteStrings(IEnumerable<ByteString> descriptorData, ExtensionRegistry registry)
		{
			ProtoPreconditions.CheckNotNull(descriptorData, "descriptorData");
			MessageParser<FileDescriptorProto> messageParser = FileDescriptorProto.Parser.WithExtensionRegistry(registry);
			List<FileDescriptor> list = new List<FileDescriptor>();
			Dictionary<string, FileDescriptor> dictionary = new Dictionary<string, FileDescriptor>();
			foreach (ByteString descriptorDatum in descriptorData)
			{
				FileDescriptorProto fileDescriptorProto = messageParser.ParseFrom(descriptorDatum);
				List<FileDescriptor> list2 = new List<FileDescriptor>();
				foreach (string item in fileDescriptorProto.Dependency)
				{
					if (!dictionary.TryGetValue(item, out var value))
					{
						throw new ArgumentException("Dependency missing: " + item);
					}
					list2.Add(value);
				}
				DescriptorPool pool = new DescriptorPool(list2);
				FileDescriptor fileDescriptor = new FileDescriptor(descriptorDatum, fileDescriptorProto, list2, pool, allowUnknownDependencies: false, null);
				fileDescriptor.CrossLink();
				list.Add(fileDescriptor);
				if (dictionary.ContainsKey(fileDescriptor.Name))
				{
					throw new ArgumentException("Duplicate descriptor name: " + fileDescriptor.Name);
				}
				dictionary.Add(fileDescriptor.Name, fileDescriptor);
			}
			return new ReadOnlyCollection<FileDescriptor>(list);
		}

		public static IReadOnlyList<FileDescriptor> BuildFromByteStrings(IEnumerable<ByteString> descriptorData)
		{
			return BuildFromByteStrings(descriptorData, null);
		}

		public override string ToString()
		{
			return "FileDescriptor for " + Name;
		}

		public FileOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<FileOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<FileOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		public static void ForceReflectionInitialization<T>()
		{
			ReflectionUtil.ForceInitialize<T>();
		}
	}
	public sealed class GeneratedClrTypeInfo
	{
		private static readonly string[] EmptyNames = new string[0];

		private static readonly GeneratedClrTypeInfo[] EmptyCodeInfo = new GeneratedClrTypeInfo[0];

		private static readonly Extension[] EmptyExtensions = new Extension[0];

		internal const DynamicallyAccessedMemberTypes MessageAccessibility = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties;

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public System.Type ClrType { get; private set; }

		public MessageParser Parser { get; }

		public string[] PropertyNames { get; }

		public Extension[] Extensions { get; }

		public string[] OneofNames { get; }

		public GeneratedClrTypeInfo[] NestedTypes { get; }

		public System.Type[] NestedEnums { get; }

		public GeneratedClrTypeInfo([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] System.Type clrType, MessageParser parser, string[] propertyNames, string[] oneofNames, System.Type[] nestedEnums, Extension[] extensions, GeneratedClrTypeInfo[] nestedTypes)
		{
			NestedTypes = nestedTypes ?? EmptyCodeInfo;
			NestedEnums = nestedEnums ?? ReflectionUtil.EmptyTypes;
			ClrType = clrType;
			Extensions = extensions ?? EmptyExtensions;
			Parser = parser;
			PropertyNames = propertyNames ?? EmptyNames;
			OneofNames = oneofNames ?? EmptyNames;
		}

		public GeneratedClrTypeInfo([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] System.Type clrType, MessageParser parser, string[] propertyNames, string[] oneofNames, System.Type[] nestedEnums, GeneratedClrTypeInfo[] nestedTypes)
			: this(clrType, parser, propertyNames, oneofNames, nestedEnums, null, nestedTypes)
		{
		}

		public GeneratedClrTypeInfo(System.Type[] nestedEnums, Extension[] extensions, GeneratedClrTypeInfo[] nestedTypes)
			: this(null, null, null, null, nestedEnums, extensions, nestedTypes)
		{
		}

		public GeneratedClrTypeInfo(System.Type[] nestedEnums, GeneratedClrTypeInfo[] nestedTypes)
			: this(null, null, null, null, nestedEnums, nestedTypes)
		{
		}
	}
	public interface IDescriptor
	{
		string Name { get; }

		string FullName { get; }

		FileDescriptor File { get; }
	}
	public interface IFieldAccessor
	{
		FieldDescriptor Descriptor { get; }

		void Clear(IMessage message);

		object GetValue(IMessage message);

		bool HasValue(IMessage message);

		void SetValue(IMessage message, object value);
	}
	internal sealed class MapFieldAccessor : FieldAccessorBase
	{
		internal MapFieldAccessor(PropertyInfo property, FieldDescriptor descriptor)
			: base(property, descriptor)
		{
		}

		public override void Clear(IMessage message)
		{
			((IDictionary)GetValue(message)).Clear();
		}

		public override bool HasValue(IMessage message)
		{
			throw new InvalidOperationException("HasValue is not implemented for map fields");
		}

		public override void SetValue(IMessage message, object value)
		{
			throw new InvalidOperationException("SetValue is not implemented for map fields");
		}
	}
	public sealed class MessageDescriptor : DescriptorBase
	{
		public sealed class FieldCollection
		{
			private readonly MessageDescriptor messageDescriptor;

			public FieldDescriptor this[int number] => messageDescriptor.FindFieldByNumber(number) ?? throw new KeyNotFoundException("No such field number");

			public FieldDescriptor this[string name] => messageDescriptor.FindFieldByName(name) ?? throw new KeyNotFoundException("No such field name");

			internal FieldCollection(MessageDescriptor messageDescriptor)
			{
				this.messageDescriptor = messageDescriptor;
			}

			public IList<FieldDescriptor> InDeclarationOrder()
			{
				return messageDescriptor.fieldsInDeclarationOrder;
			}

			public IList<FieldDescriptor> InFieldNumberOrder()
			{
				return messageDescriptor.fieldsInNumberOrder;
			}

			internal IDictionary<string, FieldDescriptor> ByJsonName()
			{
				return messageDescriptor.jsonFieldMap;
			}
		}

		private static readonly HashSet<string> WellKnownTypeNames = new HashSet<string> { "google/protobuf/any.proto", "google/protobuf/api.proto", "google/protobuf/duration.proto", "google/protobuf/empty.proto", "google/protobuf/wrappers.proto", "google/protobuf/timestamp.proto", "google/protobuf/field_mask.proto", "google/protobuf/source_context.proto", "google/protobuf/struct.proto", "google/protobuf/type.proto" };

		private readonly IList<FieldDescriptor> fieldsInDeclarationOrder;

		private readonly IList<FieldDescriptor> fieldsInNumberOrder;

		private readonly IDictionary<string, FieldDescriptor> jsonFieldMap;

		private Func<IMessage, bool> extensionSetIsInitialized;

		public override string Name => Proto.Name;

		internal DescriptorProto Proto { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public System.Type ClrType { get; }

		public MessageParser Parser { get; }

		internal bool IsWellKnownType
		{
			get
			{
				if (base.File.Package == "google.protobuf")
				{
					return WellKnownTypeNames.Contains(base.File.Name);
				}
				return false;
			}
		}

		internal bool IsWrapperType
		{
			get
			{
				if (base.File.Package == "google.protobuf")
				{
					return base.File.Name == "google/protobuf/wrappers.proto";
				}
				return false;
			}
		}

		public MessageDescriptor ContainingType { get; }

		public FieldCollection Fields { get; }

		public ExtensionCollection Extensions { get; }

		public IList<MessageDescriptor> NestedTypes { get; }

		public IList<EnumDescriptor> EnumTypes { get; }

		public IList<OneofDescriptor> Oneofs { get; }

		public int RealOneofCount { get; }

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal MessageDescriptor(DescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int typeIndex, GeneratedClrTypeInfo generatedCodeInfo)
			: base(file, file.ComputeFullName(parent, proto.Name), typeIndex)
		{
			MessageDescriptor messageDescriptor = this;
			Proto = proto;
			Parser = generatedCodeInfo?.Parser;
			ClrType = generatedCodeInfo?.ClrType;
			ContainingType = parent;
			Oneofs = DescriptorUtil.ConvertAndMakeReadOnly(proto.OneofDecl, delegate(OneofDescriptorProto oneof, int index)
			{
				FileDescriptor file2 = file;
				MessageDescriptor parent2 = messageDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new OneofDescriptor(oneof, file2, parent2, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.OneofNames[index] : null);
			});
			int num = 0;
			foreach (OneofDescriptor oneof in Oneofs)
			{
				if (oneof.IsSynthetic)
				{
					num++;
				}
				else if (num != 0)
				{
					throw new ArgumentException("All synthetic oneofs should come after real oneofs");
				}
			}
			RealOneofCount = Oneofs.Count - num;
			NestedTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.NestedType, delegate(DescriptorProto type, int index)
			{
				FileDescriptor file2 = file;
				MessageDescriptor parent2 = messageDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new MessageDescriptor(type, file2, parent2, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.NestedTypes[index] : null);
			});
			EnumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumType, delegate(EnumDescriptorProto type, int index)
			{
				FileDescriptor file2 = file;
				MessageDescriptor parent2 = messageDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new EnumDescriptor(type, file2, parent2, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.NestedEnums[index] : null);
			});
			Extensions = new ExtensionCollection(this, generatedCodeInfo?.Extensions);
			fieldsInDeclarationOrder = DescriptorUtil.ConvertAndMakeReadOnly(proto.Field, delegate(FieldDescriptorProto field, int index)
			{
				FileDescriptor file2 = file;
				MessageDescriptor parent2 = messageDescriptor;
				GeneratedClrTypeInfo generatedClrTypeInfo = generatedCodeInfo;
				return new FieldDescriptor(field, file2, parent2, index, (generatedClrTypeInfo != null) ? generatedClrTypeInfo.PropertyNames[index] : null, null);
			});
			fieldsInNumberOrder = new ReadOnlyCollection<FieldDescriptor>(fieldsInDeclarationOrder.OrderBy((FieldDescriptor field) => field.FieldNumber).ToArray());
			jsonFieldMap = CreateJsonFieldMap(fieldsInNumberOrder);
			file.DescriptorPool.AddSymbol(this);
			Fields = new FieldCollection(this);
		}

		private static System.Collections.ObjectModel.ReadOnlyDictionary<string, FieldDescriptor> CreateJsonFieldMap(IList<FieldDescriptor> fields)
		{
			Dictionary<string, FieldDescriptor> dictionary = new Dictionary<string, FieldDescriptor>();
			foreach (FieldDescriptor field in fields)
			{
				dictionary[field.Name] = field;
				dictionary[field.JsonName] = field;
			}
			return new System.Collections.ObjectModel.ReadOnlyDictionary<string, FieldDescriptor>(dictionary);
		}

		internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
		{
			return fieldNumber switch
			{
				2 => (IReadOnlyList<DescriptorBase>)fieldsInDeclarationOrder, 
				3 => (IReadOnlyList<DescriptorBase>)NestedTypes, 
				4 => (IReadOnlyList<DescriptorBase>)EnumTypes, 
				_ => null, 
			};
		}

		public DescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		internal bool IsExtensionsInitialized(IMessage message)
		{
			if (Proto.ExtensionRange.Count == 0)
			{
				return true;
			}
			if (extensionSetIsInitialized == null)
			{
				extensionSetIsInitialized = ReflectionUtil.CreateIsInitializedCaller(ClrType);
			}
			return extensionSetIsInitialized(message);
		}

		public FieldDescriptor FindFieldByName(string name)
		{
			return base.File.DescriptorPool.FindSymbol<FieldDescriptor>(base.FullName + "." + name);
		}

		public FieldDescriptor FindFieldByNumber(int number)
		{
			return base.File.DescriptorPool.FindFieldByNumber(this, number);
		}

		public T FindDescriptor<T>(string name) where T : class, IDescriptor
		{
			return base.File.DescriptorPool.FindSymbol<T>(base.FullName + "." + name);
		}

		public MessageOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<MessageOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<MessageOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		internal void CrossLink()
		{
			foreach (MessageDescriptor nestedType in NestedTypes)
			{
				nestedType.CrossLink();
			}
			foreach (FieldDescriptor item in fieldsInDeclarationOrder)
			{
				item.CrossLink();
			}
			foreach (OneofDescriptor oneof in Oneofs)
			{
				oneof.CrossLink();
			}
			Extensions.CrossLink();
		}
	}
	public sealed class MethodDescriptor : DescriptorBase
	{
		private readonly MethodDescriptorProto proto;

		private readonly ServiceDescriptor service;

		private MessageDescriptor inputType;

		private MessageDescriptor outputType;

		public ServiceDescriptor Service => service;

		public MessageDescriptor InputType => inputType;

		public MessageDescriptor OutputType => outputType;

		public bool IsClientStreaming => proto.ClientStreaming;

		public bool IsServerStreaming => proto.ServerStreaming;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal MethodDescriptorProto Proto => proto;

		public override string Name => proto.Name;

		public MethodOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<MethodOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<MethodOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		internal MethodDescriptor(MethodDescriptorProto proto, FileDescriptor file, ServiceDescriptor parent, int index)
			: base(file, parent.FullName + "." + proto.Name, index)
		{
			this.proto = proto;
			service = parent;
			file.DescriptorPool.AddSymbol(this);
		}

		public MethodDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		internal void CrossLink()
		{
			IDescriptor descriptor = base.File.DescriptorPool.LookupSymbol(Proto.InputType, this);
			if (!(descriptor is MessageDescriptor))
			{
				throw new DescriptorValidationException(this, "\"" + Proto.InputType + "\" is not a message type.");
			}
			inputType = (MessageDescriptor)descriptor;
			descriptor = base.File.DescriptorPool.LookupSymbol(Proto.OutputType, this);
			if (!(descriptor is MessageDescriptor))
			{
				throw new DescriptorValidationException(this, "\"" + Proto.OutputType + "\" is not a message type.");
			}
			outputType = (MessageDescriptor)descriptor;
		}
	}
	public sealed class OneofAccessor
	{
		private readonly Func<IMessage, int> caseDelegate;

		private readonly Action<IMessage> clearDelegate;

		public OneofDescriptor Descriptor { get; }

		private OneofAccessor(OneofDescriptor descriptor, Func<IMessage, int> caseDelegate, Action<IMessage> clearDelegate)
		{
			Descriptor = descriptor;
			this.caseDelegate = caseDelegate;
			this.clearDelegate = clearDelegate;
		}

		internal static OneofAccessor ForRegularOneof(OneofDescriptor descriptor, PropertyInfo caseProperty, MethodInfo clearMethod)
		{
			return new OneofAccessor(descriptor, ReflectionUtil.CreateFuncIMessageInt32(caseProperty.GetGetMethod()), ReflectionUtil.CreateActionIMessage(clearMethod));
		}

		internal static OneofAccessor ForSyntheticOneof(OneofDescriptor descriptor)
		{
			return new OneofAccessor(descriptor, (IMessage message) => descriptor.Fields[0].Accessor.HasValue(message) ? descriptor.Fields[0].FieldNumber : 0, delegate(IMessage message)
			{
				descriptor.Fields[0].Accessor.Clear(message);
			});
		}

		public void Clear(IMessage message)
		{
			clearDelegate(message);
		}

		public FieldDescriptor GetCaseFieldDescriptor(IMessage message)
		{
			int num = caseDelegate(message);
			if (num <= 0)
			{
				return null;
			}
			return Descriptor.ContainingType.FindFieldByNumber(num);
		}
	}
	public sealed class OneofDescriptor : DescriptorBase
	{
		private MessageDescriptor containingType;

		private IList<FieldDescriptor> fields;

		private readonly OneofAccessor accessor;

		public override string Name => Proto.Name;

		internal OneofDescriptorProto Proto { get; }

		public MessageDescriptor ContainingType => containingType;

		public IList<FieldDescriptor> Fields => fields;

		public bool IsSynthetic { get; }

		public OneofAccessor Accessor => accessor;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal OneofDescriptor(OneofDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index, string clrName)
			: base(file, file.ComputeFullName(parent, proto.Name), index)
		{
			Proto = proto;
			containingType = parent;
			file.DescriptorPool.AddSymbol(this);
			IsSynthetic = parent.Proto.Field.FirstOrDefault((FieldDescriptorProto fieldProto) => fieldProto.HasOneofIndex && fieldProto.OneofIndex == index)?.Proto3Optional ?? false;
			accessor = CreateAccessor(clrName);
		}

		public OneofDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		public OneofOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<OneofOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<OneofOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		internal void CrossLink()
		{
			List<FieldDescriptor> list = new List<FieldDescriptor>();
			foreach (FieldDescriptor item in ContainingType.Fields.InDeclarationOrder())
			{
				if (item.ContainingOneof == this)
				{
					list.Add(item);
				}
			}
			fields = new ReadOnlyCollection<FieldDescriptor>(list);
		}

		private OneofAccessor CreateAccessor(string clrName)
		{
			if (clrName == null)
			{
				return null;
			}
			if (IsSynthetic)
			{
				return OneofAccessor.ForSyntheticOneof(this);
			}
			PropertyInfo property = containingType.ClrType.GetProperty(clrName + "Case");
			if (property == null)
			{
				throw new DescriptorValidationException(this, $"Property {clrName}Case not found in {containingType.ClrType}");
			}
			if (!property.CanRead)
			{
				throw new ArgumentException($"Cannot read from property {clrName}Case in {containingType.ClrType}");
			}
			MethodInfo method = containingType.ClrType.GetMethod("Clear" + clrName);
			if (method == null)
			{
				throw new DescriptorValidationException(this, $"Method Clear{clrName} not found in {containingType.ClrType}");
			}
			return OneofAccessor.ForRegularOneof(this, property, method);
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public class OriginalNameAttribute : Attribute
	{
		public string Name { get; set; }

		public bool PreferredAlias { get; set; }

		public OriginalNameAttribute(string name)
		{
			Name = ProtoPreconditions.CheckNotNull(name, "name");
			PreferredAlias = true;
		}
	}
	internal sealed class PackageDescriptor : IDescriptor
	{
		private readonly string name;

		private readonly string fullName;

		private readonly FileDescriptor file;

		public string Name => name;

		public string FullName => fullName;

		public FileDescriptor File => file;

		internal PackageDescriptor(string name, string fullName, FileDescriptor file)
		{
			this.file = file;
			this.fullName = fullName;
			this.name = name;
		}
	}
	internal static class ReflectionUtil
	{
		private interface IReflectionHelper
		{
			Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method);

			Action<IMessage> CreateActionIMessage(MethodInfo method);

			Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method);

			Action<IMessage, object> CreateActionIMessageObject(MethodInfo method);

			Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method);
		}

		internal interface IExtensionReflectionHelper
		{
			object GetExtension(IMessage message);

			void SetExtension(IMessage message, object value);

			bool HasExtension(IMessage message);

			void ClearExtension(IMessage message);
		}

		private interface IExtensionSetReflector
		{
			Func<IMessage, bool> CreateIsInitializedCaller();
		}

		private class ReflectionHelper<T1, T2> : IReflectionHelper
		{
			public Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method)
			{
				if (CanConvertEnumFuncToInt32Func)
				{
					Func<T1, int> del = (Func<T1, int>)method.CreateDelegate(typeof(Func<T1, int>));
					return (IMessage message) => del((T1)message);
				}
				Func<T1, T2> del2 = (Func<T1, T2>)method.CreateDelegate(typeof(Func<T1, T2>));
				return (IMessage message) => (int)(object)del2((T1)message);
			}

			public Action<IMessage> CreateActionIMessage(MethodInfo method)
			{
				Action<T1> del = (Action<T1>)method.CreateDelegate(typeof(Action<T1>));
				return delegate(IMessage message)
				{
					del((T1)message);
				};
			}

			public Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method)
			{
				Func<T1, T2> del = (Func<T1, T2>)method.CreateDelegate(typeof(Func<T1, T2>));
				return (IMessage message) => del((T1)message);
			}

			public Action<IMessage, object> CreateActionIMessageObject(MethodInfo method)
			{
				Action<T1, T2> del = (Action<T1, T2>)method.CreateDelegate(typeof(Action<T1, T2>));
				return delegate(IMessage message, object arg)
				{
					del((T1)message, (T2)arg);
				};
			}

			public Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method)
			{
				Func<T1, bool> del = (Func<T1, bool>)method.CreateDelegate(typeof(Func<T1, bool>));
				return (IMessage message) => del((T1)message);
			}
		}

		private class ExtensionReflectionHelper<T1, T3> : IExtensionReflectionHelper where T1 : IExtendableMessage<T1>
		{
			private readonly Extension extension;

			public ExtensionReflectionHelper(Extension extension)
			{
				this.extension = extension;
			}

			public object GetExtension(IMessage message)
			{
				if (!(message is T1 val))
				{
					throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
				}
				if (extension is Extension<T1, T3>)
				{
					Extension<T1, T3> obj = extension as Extension<T1, T3>;
					return val.GetExtension(obj);
				}
				if (extension is RepeatedExtension<T1, T3>)
				{
					RepeatedExtension<T1, T3> obj2 = extension as RepeatedExtension<T1, T3>;
					return val.GetOrInitializeExtension(obj2);
				}
				throw new InvalidCastException("The provided extension is not a valid extension identifier type");
			}

			public bool HasExtension(IMessage message)
			{
				if (!(message is T1 val))
				{
					throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
				}
				if (extension is Extension<T1, T3>)
				{
					return val.HasExtension(extension as Extension<T1, T3>);
				}
				if (extension is RepeatedExtension<T1, T3>)
				{
					throw new InvalidOperationException("HasValue is not implemented for repeated extensions");
				}
				throw new InvalidCastException("The provided extension is not a valid extension identifier type");
			}

			public void SetExtension(IMessage message, object value)
			{
				if (!(message is T1 val))
				{
					throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
				}
				if (extension is Extension<T1, T3>)
				{
					val.SetExtension(extension as Extension<T1, T3>, (T3)value);
					return;
				}
				if (extension is RepeatedExtension<T1, T3>)
				{
					throw new InvalidOperationException("SetValue is not implemented for repeated extensions");
				}
				throw new InvalidCastException("The provided extension is not a valid extension identifier type");
			}

			public void ClearExtension(IMessage message)
			{
				if (!(message is T1 val))
				{
					throw new InvalidCastException("Cannot access extension on message that isn't IExtensionMessage");
				}
				if (extension is Extension<T1, T3>)
				{
					Extension<T1, T3> obj = extension as Extension<T1, T3>;
					val.ClearExtension(obj);
					return;
				}
				if (extension is RepeatedExtension<T1, T3>)
				{
					RepeatedExtension<T1, T3> obj2 = extension as RepeatedExtension<T1, T3>;
					val.GetExtension(obj2).Clear();
					return;
				}
				throw new InvalidCastException("The provided extension is not a valid extension identifier type");
			}
		}

		private class ExtensionSetReflector<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T1> : IExtensionSetReflector where T1 : IExtendableMessage<T1>
		{
			public Func<IMessage, bool> CreateIsInitializedCaller()
			{
				PropertyInfo declaredProperty = typeof(T1).GetTypeInfo().GetDeclaredProperty("_Extensions");
				Func<T1, ExtensionSet<T1>> getFunc = (Func<T1, ExtensionSet<T1>>)declaredProperty.GetMethod.CreateDelegate(typeof(Func<T1, ExtensionSet<T1>>));
				Func<ExtensionSet<T1>, bool> initializedFunc = (Func<ExtensionSet<T1>, bool>)typeof(ExtensionSet<T1>).GetTypeInfo().GetDeclaredMethod("IsInitialized").CreateDelegate(typeof(Func<ExtensionSet<T1>, bool>));
				return delegate(IMessage m)
				{
					ExtensionSet<T1> extensionSet = getFunc((T1)m);
					return extensionSet == null || initializedFunc(extensionSet);
				};
			}
		}

		public enum SampleEnum
		{
			X
		}

		internal static readonly System.Type[] EmptyTypes;

		private static bool CanConvertEnumFuncToInt32Func { get; }

		static ReflectionUtil()
		{
			EmptyTypes = new System.Type[0];
			CanConvertEnumFuncToInt32Func = CheckCanConvertEnumFuncToInt32Func();
			ForceInitialize<string>();
			ForceInitialize<int>();
			ForceInitialize<long>();
			ForceInitialize<uint>();
			ForceInitialize<ulong>();
			ForceInitialize<float>();
			ForceInitialize<double>();
			ForceInitialize<bool>();
			ForceInitialize<int?>();
			ForceInitialize<long?>();
			ForceInitialize<uint?>();
			ForceInitialize<ulong?>();
			ForceInitialize<float?>();
			ForceInitialize<double?>();
			ForceInitialize<bool?>();
			ForceInitialize<SampleEnum>();
			SampleEnumMethod();
		}

		internal static void ForceInitialize<T>()
		{
			new ReflectionHelper<IMessage, T>();
		}

		internal static Func<IMessage, object> CreateFuncIMessageObject(MethodInfo method)
		{
			return GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageObject(method);
		}

		internal static Func<IMessage, int> CreateFuncIMessageInt32(MethodInfo method)
		{
			return GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageInt32(method);
		}

		internal static Action<IMessage, object> CreateActionIMessageObject(MethodInfo method)
		{
			return GetReflectionHelper(method.DeclaringType, method.GetParameters()[0].ParameterType).CreateActionIMessageObject(method);
		}

		internal static Action<IMessage> CreateActionIMessage(MethodInfo method)
		{
			return GetReflectionHelper(method.DeclaringType, typeof(object)).CreateActionIMessage(method);
		}

		internal static Func<IMessage, bool> CreateFuncIMessageBool(MethodInfo method)
		{
			return GetReflectionHelper(method.DeclaringType, method.ReturnType).CreateFuncIMessageBool(method);
		}

		[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
		internal static Func<IMessage, bool> CreateIsInitializedCaller([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] System.Type msg)
		{
			return ((IExtensionSetReflector)Activator.CreateInstance(typeof(ExtensionSetReflector<>).MakeGenericType(msg))).CreateIsInitializedCaller();
		}

		[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
		internal static IExtensionReflectionHelper CreateExtensionHelper(Extension extension)
		{
			return (IExtensionReflectionHelper)Activator.CreateInstance(typeof(ExtensionReflectionHelper<, >).MakeGenericType(extension.TargetType, extension.GetType().GenericTypeArguments[1]), extension);
		}

		[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on GeneratedClrTypeInfo.ctor clrType parameter.")]
		private static IReflectionHelper GetReflectionHelper(System.Type t1, System.Type t2)
		{
			return (IReflectionHelper)Activator.CreateInstance(typeof(ReflectionHelper<, >).MakeGenericType(t1, t2));
		}

		private static bool CheckCanConvertEnumFuncToInt32Func()
		{
			try
			{
				typeof(ReflectionUtil).GetMethod("SampleEnumMethod").CreateDelegate(typeof(Func<int>));
				return true;
			}
			catch (ArgumentException)
			{
				return false;
			}
		}

		public static SampleEnum SampleEnumMethod()
		{
			return SampleEnum.X;
		}
	}
	internal sealed class RepeatedFieldAccessor : FieldAccessorBase
	{
		internal RepeatedFieldAccessor(PropertyInfo property, FieldDescriptor descriptor)
			: base(property, descriptor)
		{
		}

		public override void Clear(IMessage message)
		{
			((IList)GetValue(message)).Clear();
		}

		public override bool HasValue(IMessage message)
		{
			throw new InvalidOperationException("HasValue is not implemented for repeated fields");
		}

		public override void SetValue(IMessage message, object value)
		{
			throw new InvalidOperationException("SetValue is not implemented for repeated fields");
		}
	}
	public sealed class ServiceDescriptor : DescriptorBase
	{
		private readonly ServiceDescriptorProto proto;

		private readonly IList<MethodDescriptor> methods;

		public override string Name => proto.Name;

		internal ServiceDescriptorProto Proto => proto;

		public IList<MethodDescriptor> Methods => methods;

		[Obsolete("CustomOptions are obsolete. Use the GetOptions() method.")]
		public CustomOptions CustomOptions => new CustomOptions(Proto.Options?._extensions?.ValuesByNumber);

		internal ServiceDescriptor(ServiceDescriptorProto proto, FileDescriptor file, int index)
			: base(file, file.ComputeFullName(null, proto.Name), index)
		{
			ServiceDescriptor parent = this;
			this.proto = proto;
			methods = DescriptorUtil.ConvertAndMakeReadOnly(proto.Method, (MethodDescriptorProto method, int i) => new MethodDescriptor(method, file, parent, i));
			file.DescriptorPool.AddSymbol(this);
		}

		internal override IReadOnlyList<DescriptorBase> GetNestedDescriptorListForField(int fieldNumber)
		{
			if (fieldNumber == 2)
			{
				return (IReadOnlyList<DescriptorBase>)methods;
			}
			return null;
		}

		public ServiceDescriptorProto ToProto()
		{
			return Proto.Clone();
		}

		public MethodDescriptor FindMethodByName(string name)
		{
			return base.File.DescriptorPool.FindSymbol<MethodDescriptor>(base.FullName + "." + name);
		}

		public ServiceOptions GetOptions()
		{
			return Proto.Options?.Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public T GetOption<T>(Extension<ServiceOptions, T> extension)
		{
			T extension2 = Proto.Options.GetExtension(extension);
			if (!(extension2 is IDeepCloneable<T>))
			{
				return extension2;
			}
			return (extension2 as IDeepCloneable<T>).Clone();
		}

		[Obsolete("GetOption is obsolete. Use the GetOptions() method.")]
		public RepeatedField<T> GetOption<T>(RepeatedExtension<ServiceOptions, T> extension)
		{
			return Proto.Options.GetExtension(extension).Clone();
		}

		internal void CrossLink()
		{
			foreach (MethodDescriptor method in methods)
			{
				method.CrossLink();
			}
		}
	}
	internal sealed class SingleFieldAccessor : FieldAccessorBase
	{
		private readonly Action<IMessage, object> setValueDelegate;

		private readonly Action<IMessage> clearDelegate;

		private readonly Func<IMessage, bool> hasDelegate;

		internal SingleFieldAccessor([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] System.Type messageType, PropertyInfo property, FieldDescriptor descriptor)
			: base(property, descriptor)
		{
			SingleFieldAccessor singleFieldAccessor = this;
			if (!property.CanWrite)
			{
				throw new ArgumentException("Not all required properties/methods available");
			}
			setValueDelegate = ReflectionUtil.CreateActionIMessageObject(property.GetSetMethod());
			if (descriptor.FieldType == FieldType.Message)
			{
				hasDelegate = (IMessage message) => singleFieldAccessor.GetValue(message) != null;
				clearDelegate = delegate(IMessage message)
				{
					singleFieldAccessor.SetValue(message, null);
				};
			}
			else if (descriptor.RealContainingOneof != null)
			{
				OneofAccessor oneofAccessor = descriptor.RealContainingOneof.Accessor;
				hasDelegate = (IMessage message) => oneofAccessor.GetCaseFieldDescriptor(message) == descriptor;
				clearDelegate = delegate(IMessage message)
				{
					if (oneofAccessor.GetCaseFieldDescriptor(message) == descriptor)
					{
						oneofAccessor.Clear(message);
					}
				};
			}
			else if (descriptor.File.Syntax == Syntax.Proto2 || descriptor.Proto.Proto3Optional)
			{
				MethodInfo getMethod = messageType.GetRuntimeProperty("Has" + property.Name).GetMethod;
				if (getMethod == null)
				{
					throw new ArgumentException("Not all required properties/methods are available");
				}
				hasDelegate = ReflectionUtil.CreateFuncIMessageBool(getMethod);
				MethodInfo runtimeMethod = messageType.GetRuntimeMethod("Clear" + property.Name, ReflectionUtil.EmptyTypes);
				if (runtimeMethod == null)
				{
					throw new ArgumentException("Not all required properties/methods are available");
				}
				clearDelegate = ReflectionUtil.CreateActionIMessage(runtimeMethod);
			}
			else
			{
				hasDelegate = delegate
				{
					throw new InvalidOperationException("Presence is not implemented for this field");
				};
				object defaultValue = GetDefaultValue(descriptor);
				clearDelegate = delegate(IMessage message)
				{
					singleFieldAccessor.SetValue(message, defaultValue);
				};
			}
		}

		private static object GetDefaultValue(FieldDescriptor descriptor)
		{
			switch (descriptor.FieldType)
			{
			case FieldType.Bool:
				return false;
			case FieldType.Bytes:
				return ByteString.Empty;
			case FieldType.String:
				return "";
			case FieldType.Double:
				return 0.0;
			case FieldType.Int32:
			case FieldType.SFixed32:
			case FieldType.SInt32:
			case FieldType.Enum:
				return 0;
			case FieldType.Fixed32:
			case FieldType.UInt32:
				return 0u;
			case FieldType.UInt64:
			case FieldType.Fixed64:
				return 0uL;
			case FieldType.Int64:
			case FieldType.SFixed64:
			case FieldType.SInt64:
				return 0L;
			case FieldType.Float:
				return 0f;
			case FieldType.Group:
			case FieldType.Message:
				return null;
			default:
				throw new ArgumentException("Invalid field type");
			}
		}

		public override void Clear(IMessage message)
		{
			clearDelegate(message);
		}

		public override bool HasValue(IMessage message)
		{
			return hasDelegate(message);
		}

		public override void SetValue(IMessage message, object value)
		{
			setValueDelegate(message, value);
		}
	}
	public sealed class TypeRegistry
	{
		private class Builder
		{
			private readonly Dictionary<string, MessageDescriptor> types;

			private readonly HashSet<string> fileDescriptorNames;

			internal Builder()
			{
				types = new Dictionary<string, MessageDescriptor>();
				fileDescriptorNames = new HashSet<string>();
			}

			internal void AddFile(FileDescriptor fileDescriptor)
			{
				if (!fileDescriptorNames.Add(fileDescriptor.Name))
				{
					return;
				}
				foreach (FileDescriptor dependency in fileDescriptor.Dependencies)
				{
					AddFile(dependency);
				}
				foreach (MessageDescriptor messageType in fileDescriptor.MessageTypes)
				{
					AddMessage(messageType);
				}
			}

			private void AddMessage(MessageDescriptor messageDescriptor)
			{
				foreach (MessageDescriptor nestedType in messageDescriptor.NestedTypes)
				{
					AddMessage(nestedType);
				}
				types[messageDescriptor.FullName] = messageDescriptor;
			}

			internal TypeRegistry Build()
			{
				return new TypeRegistry(types);
			}
		}

		private readonly Dictionary<string, MessageDescriptor> fullNameToMessageMap;

		public static TypeRegistry Empty { get; } = new TypeRegistry(new Dictionary<string, MessageDescriptor>());

		private TypeRegistry(Dictionary<string, MessageDescriptor> fullNameToMessageMap)
		{
			this.fullNameToMessageMap = fullNameToMessageMap;
		}

		public MessageDescriptor Find(string fullName)
		{
			fullNameToMessageMap.TryGetValue(fullName, out var value);
			return value;
		}

		public static TypeRegistry FromFiles(params FileDescriptor[] fileDescriptors)
		{
			return FromFiles((IEnumerable<FileDescriptor>)fileDescriptors);
		}

		public static TypeRegistry FromFiles(IEnumerable<FileDescriptor> fileDescriptors)
		{
			ProtoPreconditions.CheckNotNull(fileDescriptors, "fileDescriptors");
			Builder builder = new Builder();
			foreach (FileDescriptor fileDescriptor in fileDescriptors)
			{
				builder.AddFile(fileDescriptor);
			}
			return builder.Build();
		}

		public static TypeRegistry FromMessages(params MessageDescriptor[] messageDescriptors)
		{
			return FromMessages((IEnumerable<MessageDescriptor>)messageDescriptors);
		}

		public static TypeRegistry FromMessages(IEnumerable<MessageDescriptor> messageDescriptors)
		{
			ProtoPreconditions.CheckNotNull(messageDescriptors, "messageDescriptors");
			return FromFiles(messageDescriptors.Select((MessageDescriptor md) => md.File));
		}
	}
}
namespace Google.Protobuf.Compatibility
{
	internal static class PropertyInfoExtensions
	{
		internal static MethodInfo GetGetMethod(this PropertyInfo target)
		{
			MethodInfo getMethod = target.GetMethod;
			if (!(getMethod != null) || !getMethod.IsPublic)
			{
				return null;
			}
			return getMethod;
		}

		internal static MethodInfo GetSetMethod(this PropertyInfo target)
		{
			MethodInfo setMethod = target.SetMethod;
			if (!(setMethod != null) || !setMethod.IsPublic)
			{
				return null;
			}
			return setMethod;
		}
	}
	internal static class TypeExtensions
	{
		internal static bool IsAssignableFrom(this System.Type target, System.Type c)
		{
			return target.GetTypeInfo().IsAssignableFrom(c.GetTypeInfo());
		}

		[UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "The BaseType of the target will have all properties because of the annotation.")]
		internal static PropertyInfo GetProperty([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] this System.Type target, string name)
		{
			while (target != null)
			{
				TypeInfo typeInfo = target.GetTypeInfo();
				PropertyInfo declaredProperty = typeInfo.GetDeclaredProperty(name);
				if (declaredProperty != null && ((declaredProperty.CanRead && declaredProperty.GetMethod.IsPublic) || (declaredProperty.CanWrite && declaredProperty.SetMethod.IsPublic)))
				{
					return declaredProperty;
				}
				target = typeInfo.BaseType;
			}
			return null;
		}

		[UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "The BaseType of the target will have all properties because of the annotation.")]
		internal static MethodInfo GetMethod([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] this System.Type target, string name)
		{
			while (target != null)
			{
				TypeInfo typeInfo = target.GetTypeInfo();
				MethodInfo declaredMethod = typeInfo.GetDeclaredMethod(name);
				if (declaredMethod != null && declaredMethod.IsPublic)
				{
					return declaredMethod;
				}
				target = typeInfo.BaseType;
			}
			return null;
		}
	}
}
namespace Google.Protobuf.Collections
{
	public static class Lists
	{
		public static bool Equals<T>(List<T> left, List<T> right)
		{
			if (left == right)
			{
				return true;
			}
			if (left == null || right == null)
			{
				return false;
			}
			if (left.Count != right.Count)
			{
				return false;
			}
			IEqualityComparer<T> equalityComparer = EqualityComparer<T>.Default;
			for (int i = 0; i < left.Count; i++)
			{
				if (!equalityComparer.Equals(left[i], right[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static int GetHashCode<T>(List<T> list)
		{
			if (list == null)
			{
				return 0;
			}
			int num = 31;
			foreach (T item in list)
			{
				num = num * 29 + item.GetHashCode();
			}
			return num;
		}
	}
	public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IEquatable<MapField<TKey, TValue>>, IDictionary, ICollection, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public object Current => Entry;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object Value => enumerator.Current.Value;

			internal DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		public sealed class Codec
		{
			private readonly FieldCodec<TKey> keyCodec;

			private readonly FieldCodec<TValue> valueCodec;

			private readonly uint mapTag;

			internal FieldCodec<TKey> KeyCodec => keyCodec;

			internal FieldCodec<TValue> ValueCodec => valueCodec;

			internal uint MapTag => mapTag;

			public Codec(FieldCodec<TKey> keyCodec, FieldCodec<TValue> valueCodec, uint mapTag)
			{
				this.keyCodec = keyCodec;
				this.valueCodec = valueCodec;
				this.mapTag = mapTag;
			}
		}

		private class MapView<T> : ICollection<T>, IEnumerable<T>, IEnumerable, ICollection
		{
			private readonly MapField<TKey, TValue> parent;

			private readonly Func<KeyValuePair<TKey, TValue>, T> projection;

			private readonly Func<T, bool> containsCheck;

			public int Count => parent.Count;

			public bool IsReadOnly => true;

			public bool IsSynchronized => false;

			public object SyncRoot => parent;

			internal MapView(MapField<TKey, TValue> parent, Func<KeyValuePair<TKey, TValue>, T> projection, Func<T, bool> containsCheck)
			{
				this.parent = parent;
				this.projection = projection;
				this.containsCheck = containsCheck;
			}

			public void Add(T item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(T item)
			{
				return containsCheck(item);
			}

			public void CopyTo(T[] array, int arrayIndex)
			{
				if (arrayIndex < 0)
				{
					throw new ArgumentOutOfRangeException("arrayIndex");
				}
				if (arrayIndex + Count > array.Length)
				{
					throw new ArgumentException("Not enough space in the array", "array");
				}
				using IEnumerator<T> enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			public IEnumerator<T> GetEnumerator()
			{
				return parent.list.Select(projection).GetEnumerator();
			}

			public bool Remove(T item)
			{
				throw new NotSupportedException();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public void CopyTo(Array array, int index)
			{
				if (index < 0)
				{
					throw new ArgumentOutOfRangeException("index");
				}
				if (index + Count > array.Length)
				{
					throw new ArgumentException("Not enough space in the array", "array");
				}
				using IEnumerator<T> enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array.SetValue(current, index++);
				}
			}
		}

		private static readonly EqualityComparer<TValue> ValueEqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<TValue>();

		private static readonly EqualityComparer<TKey> KeyEqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<TKey>();

		private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map = new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>(KeyEqualityComparer);

		private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>();

		public TValue this[TKey key]
		{
			get
			{
				ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				throw new KeyNotFoundException();
			}
			set
			{
				ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
				if (value == null)
				{
					ProtoPreconditions.CheckNotNullUnconstrained(value, "value");
				}
				KeyValuePair<TKey, TValue> value2 = new KeyValuePair<TKey, TValue>(key, value);
				if (map.TryGetValue(key, out var value3))
				{
					value3.Value = value2;
					return;
				}
				value3 = list.AddLast(value2);
				map[key] = value3;
			}
		}

		public ICollection<TKey> Keys => new MapView<TKey>(this, (KeyValuePair<TKey, TValue> pair) => pair.Key, ContainsKey);

		public ICollection<TValue> Values => new MapView<TValue>(this, (KeyValuePair<TKey, TValue> pair) => pair.Value, ContainsValue);

		public int Count => list.Count;

		public bool IsReadOnly => false;

		bool IDictionary.IsFixedSize => false;

		ICollection IDictionary.Keys => (ICollection)Keys;

		ICollection IDictionary.Values => (ICollection)Values;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		object IDictionary.this[object key]
		{
			get
			{
				ProtoPreconditions.CheckNotNull(key, "key");
				if (!(key is TKey))
				{
					return null;
				}
				TryGetValue((TKey)key, out var value);
				return value;
			}
			set
			{
				this[(TKey)key] = (TValue)value;
			}
		}

		IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;

		IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;

		public MapField<TKey, TValue> Clone()
		{
			MapField<TKey, TValue> mapField = new MapField<TKey, TValue>();
			if (typeof(IDeepCloneable<TValue>).IsAssignableFrom(typeof(TValue)))
			{
				foreach (KeyValuePair<TKey, TValue> item in list)
				{
					mapField.Add(item.Key, ((IDeepCloneable<TValue>)(object)item.Value).Clone());
				}
			}
			else
			{
				mapField.Add(this);
			}
			return mapField;
		}

		public void Add(TKey key, TValue value)
		{
			if (ContainsKey(key))
			{
				throw new ArgumentException("Key already exists in map", "key");
			}
			this[key] = value;
		}

		public bool ContainsKey(TKey key)
		{
			ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
			return map.ContainsKey(key);
		}

		private bool ContainsValue(TValue value)
		{
			return list.Any((KeyValuePair<TKey, TValue> pair) => ValueEqualityComparer.Equals(pair.Value, value));
		}

		public bool Remove(TKey key)
		{
			ProtoPreconditions.CheckNotNullUnconstrained(key, "key");
			if (map.TryGetValue(key, out var value))
			{
				map.Remove(key);
				value.List.Remove(value);
				return true;
			}
			return false;
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			if (map.TryGetValue(key, out var value2))
			{
				value = value2.Value.Value;
				return true;
			}
			value = default(TValue);
			return false;
		}

		public void Add(IDictionary<TKey, TValue> entries)
		{
			ProtoPreconditions.CheckNotNull(entries, "entries");
			foreach (KeyValuePair<TKey, TValue> entry in entries)
			{
				Add(entry.Key, entry.Value);
			}
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			Add(item.Key, item.Value);
		}

		public void Clear()
		{
			list.Clear();
			map.Clear();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
		{
			if (TryGetValue(item.Key, out var value))
			{
				return ValueEqualityComparer.Equals(item.Value, value);
			}
			return false;
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			if (item.Key == null)
			{
				throw new ArgumentException("Key is null", "item");
			}
			if (map.TryGetValue(item.Key, out var value) && EqualityComparer<TValue>.Default.Equals(item.Value, value.Value.Value))
			{
				map.Remove(item.Key);
				value.List.Remove(value);
				return true;
			}
			return false;
		}

		public override bool Equals(object other)
		{
			return Equals(other as MapField<TKey, TValue>);
		}

		public override int GetHashCode()
		{
			EqualityComparer<TKey> keyEqualityComparer = KeyEqualityComparer;
			EqualityComparer<TValue> valueEqualityComparer = ValueEqualityComparer;
			int num = 0;
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				num ^= keyEqualityComparer.GetHashCode(item.Key) * 31 + valueEqualityComparer.GetHashCode(item.Value);
			}
			return num;
		}

		public bool Equals(MapField<TKey, TValue> other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (other.Count != Count)
			{
				return false;
			}
			EqualityComparer<TValue> valueEqualityComparer = ValueEqualityComparer;
			using (IEnumerator<KeyValuePair<TKey, TValue>> enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					if (!other.TryGetValue(current.Key, out var value))
					{
						return false;
					}
					if (!valueEqualityComparer.Equals(value, current.Value))
					{
						return false;
					}
				}
			}
			return true;
		}

		public void AddEntriesFrom(CodedInputStream input, Codec codec)
		{
			ParseContext.Initialize(input, out var ctx);
			try
			{
				AddEntriesFrom(ref ctx, codec);
			}
			finally
			{
				ctx.CopyStateTo(input);
			}
		}

		[SecuritySafeCritical]
		public void AddEntriesFrom(ref ParseContext ctx, Codec codec)
		{
			do
			{
				KeyValuePair<TKey, TValue> keyValuePair = ParsingPrimitivesMessages.ReadMapEntry(ref ctx, codec);
				this[keyValuePair.Key] = keyValuePair.Value;
			}
			while (ParsingPrimitives.MaybeConsumeTag(ref ctx.buffer, ref ctx.state, codec.MapTag));
		}

		public void WriteTo(CodedOutputStream output, Codec codec)
		{
			WriteContext.Initialize(output, out var ctx);
			try
			{
				WriteTo(ref ctx, codec);
			}
			finally
			{
				ctx.CopyStateTo(output);
			}
		}

		[SecuritySafeCritical]
		public void WriteTo(ref WriteContext ctx, Codec codec)
		{
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				ctx.WriteTag(codec.MapTag);
				WritingPrimitives.WriteLength(ref ctx.buffer, ref ctx.state, CalculateEntrySize(codec, item));
				codec.KeyCodec.WriteTagAndValue(ref ctx, item.Key);
				codec.ValueCodec.WriteTagAndValue(ref ctx, item.Value);
			}
		}

		public int CalculateSize(Codec codec)
		{
			if (Count == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				int num2 = CalculateEntrySize(codec, item);
				num += CodedOutputStream.ComputeRawVarint32Size(codec.MapTag);
				num += CodedOutputStream.ComputeLengthSize(num2) + num2;
			}
			return num;
		}

		private static int CalculateEntrySize(Codec codec, KeyValuePair<TKey, TValue> entry)
		{
			return codec.KeyCodec.CalculateSizeWithTag(entry.Key) + codec.ValueCodec.CalculateSizeWithTag(entry.Value);
		}

		public override string ToString()
		{
			StringWriter stringWriter = new StringWriter();
			JsonFormatter.Default.WriteDictionary(stringWriter, this);
			return stringWriter.ToString();
		}

		void IDictionary.Add(object key, object value)
		{
			Add((TKey)key, (TValue)value);
		}

		bool IDictionary.Contains(object key)
		{
			if (!(key is TKey))
			{
				return false;
			}
			return ContainsKey((TKey)key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator(GetEnumerator());
		}

		void IDictionary.Remove(object key)
		{
			ProtoPreconditions.CheckNotNull(key, "key");
			if (key is TKey)
			{
				Remove((TKey)key);
			}
		}

		void ICollection.CopyTo(Array array, int index)
		{
			((ICollection)this.Select((KeyValuePair<TKey, TValue> pair) => new DictionaryEntry(pair.Key, pair.Value)).ToList()).CopyTo(array, index);
		}
	}
	public static class ProtobufEqualityComparers
	{
		private class BitwiseDoubleEqualityComparerImpl : EqualityComparer<double>
		{
			public override bool Equals(double x, double y)
			{
				return BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y);
			}

			public override int GetHashCode(double obj)
			{
				return BitConverter.DoubleToInt64Bits(obj).GetHashCode();
			}
		}

		private class BitwiseSingleEqualityComparerImpl : EqualityComparer<float>
		{
			public override bool Equals(float x, float y)
			{
				return BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y);
			}

			public override int GetHashCode(float obj)
			{
				return BitConverter.DoubleToInt64Bits(obj).GetHashCode();
			}
		}

		private class BitwiseNullableDoubleEqualityComparerImpl : EqualityComparer<double?>
		{
			public override bool Equals(double? x, double? y)
			{
				if (x.HasValue || y.HasValue)
				{
					if (x.HasValue && y.HasValue)
					{
						return BitwiseDoubleEqualityComparer.Equals(x.Value, y.Value);
					}
					return false;
				}
				return true;
			}

			public override int GetHashCode(double? obj)
			{
				if (obj.HasValue)
				{
					return BitwiseDoubleEqualityComparer.GetHashCode(obj.Value);
				}
				return 293864;
			}
		}

		private class BitwiseNullableSingleEqualityComparerImpl : EqualityComparer<float?>
		{
			public override bool Equals(float? x, float? y)
			{
				if (x.HasValue || y.HasValue)
				{
					if (x.HasValue && y.HasValue)
					{
						return BitwiseSingleEqualityComparer.Equals(x.Value, y.Value);
					}
					return false;
				}
				return true;
			}

			public override int GetHashCode(float? obj)
			{
				if (obj.HasValue)
				{
					return BitwiseSingleEqualityComparer.GetHashCode(obj.Value);
				}
				return 293864;
			}
		}

		public static EqualityComparer<double> BitwiseDoubleEqualityComparer { get; } = new BitwiseDoubleEqualityComparerImpl();

		public static EqualityComparer<float> BitwiseSingleEqualityComparer { get; } = new BitwiseSingleEqualityComparerImpl();

		public static EqualityComparer<double?> BitwiseNullableDoubleEqualityComparer { get; } = new BitwiseNullableDoubleEqualityComparerImpl();

		public static EqualityComparer<float?> BitwiseNullableSingleEqualityComparer { get; } = new BitwiseNullableSingleEqualityComparerImpl();

		public static EqualityComparer<T> GetEqualityComparer<T>()
		{
			if (!(typeof(T) == typeof(double)))
			{
				if (!(typeof(T) == typeof(float)))
				{
					if (!(typeof(T) == typeof(double?)))
					{
						if (!(typeof(T) == typeof(float?)))
						{
							return EqualityComparer<T>.Default;
						}
						return (EqualityComparer<T>)(object)BitwiseNullableSingleEqualityComparer;
					}
					return (EqualityComparer<T>)(object)BitwiseNullableDoubleEqualityComparer;
				}
				return (EqualityComparer<T>)(object)BitwiseSingleEqualityComparer;
			}
			return (EqualityComparer<T>)(object)BitwiseDoubleEqualityComparer;
		}
	}
	internal sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		private readonly IDictionary<TKey, TValue> wrapped;

		public ICollection<TKey> Keys => wrapped.Keys;

		public ICollection<TValue> Values => wrapped.Values;

		public TValue this[TKey key]
		{
			get
			{
				return wrapped[key];
			}
			set
			{
				throw new InvalidOperationException();
			}
		}

		public int Count => wrapped.Count;

		public bool IsReadOnly => true;

		public ReadOnlyDictionary(IDictionary<TKey, TValue> wrapped)
		{
			this.wrapped = wrapped;
		}

		public void Add(TKey key, TValue value)
		{
			throw new InvalidOperationException();
		}

		public bool ContainsKey(TKey key)
		{
			return wrapped.ContainsKey(key);
		}

		public bool Remove(TKey key)
		{
			throw new InvalidOperationException();
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			return wrapped.TryGetValue(key, out value);
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			throw new InvalidOperationException();
		}

		public void Clear()
		{
			throw new InvalidOperationException();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return wrapped.Contains(item);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			wrapped.CopyTo(array, arrayIndex);
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new InvalidOperationException();
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return wrapped.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable)wrapped).GetEnumerator();
		}

		public override bool Equals(object obj)
		{
			return wrapped.Equals(obj);
		}

		public override int GetHashCode()
		{
			return wrapped.GetHashCode();
		}

		public override string ToString()
		{
			return wrapped.ToString();
		}
	}
	public sealed class RepeatedField<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IDeepCloneable<RepeatedField<T>>, IEquatable<RepeatedField<T>>, IReadOnlyList<T>, IReadOnlyCollection<T>
	{
		private static readonly EqualityComparer<T> EqualityComparer = ProtobufEqualityComparers.GetEqualityComparer<T>();

		private static readonly T[] EmptyArray = new T[0];

		private const int MinArraySize = 8;

		private T[] array = EmptyArray;

		private int count;

		public int Capacity
		{
			get
			{
				return array.Length;
			}
			set
			{
				if (value < count)
				{
					throw new ArgumentOutOfRangeException("Capacity", value, $"Cannot set Capacity to a value smaller than the current item count, {count}");
				}
				if (value >= 0 && value != array.Length)
				{
					SetSize(value);
				}
			}
		}

		public int Count => count;

		public bool IsReadOnly => false;

		public T this[int index]
		{
			get
			{
				if (index < 0 || index >= count)
				{
					throw new ArgumentOutOfRangeException("index");
				}
				return array[index];
			}
			set
			{
				if (index < 0 || index >= count)
				{
					throw new ArgumentOutOfRangeException("index");
				}
				ProtoPreconditions.CheckNotNullUnconstrained(value, "value");
				array[index] = value;
			}
		}

		bool IList.IsFixedSize => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => this;

		object IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				this[index] = (T)value;
			}
		}

		public RepeatedField<T> Clone()
		{
			RepeatedField<T> repeatedField = new RepeatedField<T>();
			if (this.array != EmptyArray)
			{
				repeatedField.array = (T[])this.array.Clone();
				if (repeatedField.array is IDeepCloneable<T>[] array)
				{
					for (int i = 0; i < count; i++)
					{
						repeatedField.array[i] = array[i].Clone();
					}
				}
			}
			repeatedField.count = count;
			return repeatedField;
		}

		public void AddEntriesFrom(CodedInputStream input, FieldCodec<T> codec)
		{
			ParseContext.Initialize(input, out var ctx);
			try
			{
				AddEntriesFrom(ref ctx, codec);
			}
			finally
			{
				ctx.CopyStateTo(input);
			}
		}

		[SecuritySafeCritical]
		public void AddEntriesFrom(ref ParseContext ctx, FieldCodec<T> codec)
		{
			uint lastTag = ctx.state.lastTag;
			ValueReader<T> valueReader = codec.ValueReader;
			if (FieldCodec<T>.IsPackedRepeatedField(lastTag))
			{
				int num = ctx.ReadLength();
				if (num <= 0)
				{
					return;
				}
				int oldLimit = SegmentedBufferHelper.PushLimit(ref ctx.state, num);
				if (codec.FixedSize > 0 && num % codec.FixedSize == 0 && ParsingPrimitives.IsDataAvailable(ref ctx.state, num))
				{
					EnsureSize(count + num / codec.FixedSize);
					while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
					{
						array[count++] = valueReader(ref ctx);
					}
				}
				else
				{
					while (!SegmentedBufferHelper.IsReachedLimit(ref ctx.state))
					{
						Add(valueReader(ref ctx));
					}
				}
				SegmentedBufferHelper.PopLimit(ref ctx.state, oldLimit);
			}
			else
			{
				do
				{
					Add(valueReader(ref ctx));
				}
				while (ParsingPrimitives.MaybeConsumeTag(ref ctx.buffer, ref ctx.state, lastTag));
			}
		}

		public int CalculateSize(FieldCodec<T> codec)
		{
			if (count == 0)
			{
				return 0;
			}
			uint tag = codec.Tag;
			if (codec.PackedRepeatedField)
			{
				int num = CalculatePackedDataSize(codec);
				return CodedOutputStream.ComputeRawVarint32Size(tag) + CodedOutputStream.ComputeLengthSize(num) + num;
			}
			Func<T, int> valueSizeCalculator = codec.ValueSizeCalculator;
			int num2 = count * CodedOutputStream.ComputeRawVarint32Size(tag);
			if (codec.EndTag != 0)
			{
				num2 += count * CodedOutputStream.ComputeRawVarint32Size(codec.EndTag);
			}
			for (int i = 0; i < count; i++)
			{
				num2 += valueSizeCalculator(array[i]);
			}
			return num2;
		}

		private int CalculatePackedDataSize(FieldCodec<T> codec)
		{
			int fixedSize = codec.FixedSize;
			if (fixedSize == 0)
			{
				Func<T, int> valueSizeCalculator = codec.ValueSizeCalculator;
				int num = 0;
				for (int i = 0; i < count; i++)
				{
					num += valueSizeCalculator(array[i]);
				}
				return num;
			}
			return fixedSize * Count;
		}

		public void WriteTo(CodedOutputStream output, FieldCodec<T> codec)
		{
			WriteContext.Initialize(output, out var ctx);
			try
			{
				WriteTo(ref ctx, codec);
			}
			finally
			{
				ctx.CopyStateTo(output);
			}
		}

		[SecuritySafeCritical]
		public void WriteTo(ref WriteContext ctx, FieldCodec<T> codec)
		{
			if (count == 0)
			{
				return;
			}
			ValueWriter<T> valueWriter = codec.ValueWriter;
			uint tag = codec.Tag;
			if (codec.PackedRepeatedField)
			{
				int length = CalculatePackedDataSize(codec);
				ctx.WriteTag(tag);
				ctx.WriteLength(length);
				for (int i = 0; i < count; i++)
				{
					valueWriter(ref ctx, array[i]);
				}
				return;
			}
			for (int j = 0; j < count; j++)
			{
				ctx.WriteTag(tag);
				valueWriter(ref ctx, array[j]);
				if (codec.EndTag != 0)
				{
					ctx.WriteTag(codec.EndTag);
				}
			}
		}

		private void EnsureSize(int size)
		{
			if (array.Length < size)
			{
				size = Math.Max(size, 8);
				int size2 = Math.Max(array.Length * 2, size);
				SetSize(size2);
			}
		}

		private void SetSize(int size)
		{
			if (size != array.Length)
			{
				T[] destinationArray = new T[size];
				Array.Copy(array, 0, destinationArray, 0, count);
				array = destinationArray;
			}
		}

		public void Add(T item)
		{
			ProtoPreconditions.CheckNotNullUnconstrained(item, "item");
			EnsureSize(count + 1);
			array[count++] = item;
		}

		public void Clear()
		{
			array = EmptyArray;
			count = 0;
		}

		public bool Contains(T item)
		{
			return IndexOf(item) != -1;
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			Array.Copy(this.array, 0, array, arrayIndex, count);
		}

		public bool Remove(T item)
		{
			int num = IndexOf(item);
			if (num == -1)
			{
				return false;
			}
			Array.Copy(array, num + 1, array, num, count - num - 1);
			count--;
			array[count] = default(T);
			return true;
		}

		public void AddRange(IEnumerable<T> values)
		{
			ProtoPreconditions.CheckNotNull(values, "values");
			if (values is RepeatedField<T> repeatedField)
			{
				EnsureSize(count + repeatedField.count);
				Array.Copy(repeatedField.array, 0, array, count, repeatedField.count);
				count += repeatedField.count;
				return;
			}
			if (values is ICollection { Count: var num } collection)
			{
				if (default(T) == null)
				{
					foreach (object item in collection)
					{
						if (item == null)
						{
							throw new ArgumentException("Sequence contained null element", "values");
						}
					}
				}
				EnsureSize(count + num);
				collection.CopyTo(array, count);
				count += num;
				return;
			}
			foreach (T value in values)
			{
				Add(value);
			}
		}

		public void Add(IEnumerable<T> values)
		{
			AddRange(values);
		}

		public IEnumerator<T> GetEnumerator()
		{
			for (int i = 0; i < count; i++)
			{
				yield return array[i];
			}
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as RepeatedField<T>);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public override int GetHashCode()
		{
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				num = num * 31 + array[i].GetHashCode();
			}
			return num;
		}

		public bool Equals(RepeatedField<T> other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (other.Count != Count)
			{
				return false;
			}
			EqualityComparer<T> equalityComparer = EqualityComparer;
			for (int i = 0; i < count; i++)
			{
				if (!equalityComparer.Equals(array[i], other.array[i]))
				{
					return false;
				}
			}
			return true;
		}

		public int IndexOf(T item)
		{
			ProtoPreconditions.CheckNotNullUnconstrained(item, "item");
			EqualityComparer<T> equalityComparer = EqualityComparer;
			for (int i = 0; i < count; i++)
			{
				if (equalityComparer.Equals(array[i], item))
				{
					return i;
				}
			}
			return -1;
		}

		public void Insert(int index, T item)
		{
			ProtoPreconditions.CheckNotNullUnconstrained(item, "item");
			if (index < 0 || index > count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			EnsureSize(count + 1);
			Array.Copy(array, index, array, index + 1, count - index);
			array[index] = item;
			count++;
		}

		public void RemoveAt(int index)
		{
			if (index < 0 || index >= count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			Array.Copy(array, index + 1, array, index, count - index - 1);
			count--;
			array[count] = default(T);
		}

		public override string ToString()
		{
			StringWriter stringWriter = new StringWriter();
			JsonFormatter.Default.WriteList(stringWriter, this);
			return stringWriter.ToString();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			Array.Copy(this.array, 0, array, index, count);
		}

		int IList.Add(object value)
		{
			Add((T)value);
			return count - 1;
		}

		bool IList.Contains(object value)
		{
			if (value is T)
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (!(value is T))
			{
				return -1;
			}
			return IndexOf((T)value);
		}

		void IList.Insert(int index, object value)
		{
			Insert(index, (T)value);
		}

		void IList.Remove(object value)
		{
			if (value is T)
			{
				Remove((T)value);
			}
		}
	}
}