using System;
using System.Collections;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using Cpp2IlInjected;

namespace System.Text
{
	/// <summary>Represents a character encoding.</summary>
	// Token: 0x020001DA RID: 474
	[Token(Token = "0x20001DA")]
	[ComVisible(true)]
	[Serializable]
	public abstract class Encoding : ICloneable
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.Encoding" /> class.</summary>
		// Token: 0x060011C7 RID: 4551 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011C7")]
		[Address(RVA = "0xD2D280", Offset = "0xD2C280", VA = "0x180D2D280")]
		protected Encoding()
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.Encoding" /> class that corresponds to the specified code page.</summary>
		/// <param name="codePage">The code page identifier of the preferred encoding.  
		///  -or-  
		///  0, to use the default encoding.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="codePage" /> is less than zero.</exception>
		// Token: 0x060011C8 RID: 4552 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011C8")]
		[Address(RVA = "0xD2D1F0", Offset = "0xD2C1F0", VA = "0x180D2D1F0")]
		protected Encoding(int codePage)
		{
		}

		// Token: 0x060011C9 RID: 4553 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011C9")]
		[Address(RVA = "0xD2CE60", Offset = "0xD2BE60", VA = "0x180D2CE60", Slot = "5")]
		internal virtual void SetDefaultFallbacks()
		{
		}

		// Token: 0x060011CA RID: 4554 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CA")]
		[Address(RVA = "0xD2CD40", Offset = "0xD2BD40", VA = "0x180D2CD40")]
		internal void OnDeserializing()
		{
		}

		// Token: 0x060011CB RID: 4555 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CB")]
		[Address(RVA = "0xD2CCF0", Offset = "0xD2BCF0", VA = "0x180D2CCF0")]
		internal void OnDeserialized()
		{
		}

		// Token: 0x060011CC RID: 4556 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CC")]
		[Address(RVA = "0xD2CD40", Offset = "0xD2BD40", VA = "0x180D2CD40")]
		[OnDeserializing]
		private void OnDeserializing(StreamingContext ctx)
		{
		}

		// Token: 0x060011CD RID: 4557 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CD")]
		[Address(RVA = "0xD2CCF0", Offset = "0xD2BCF0", VA = "0x180D2CCF0")]
		[OnDeserialized]
		private void OnDeserialized(StreamingContext ctx)
		{
		}

		// Token: 0x060011CE RID: 4558 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CE")]
		[Address(RVA = "0x8114D0", Offset = "0x8104D0", VA = "0x1808114D0")]
		[OnSerializing]
		private void OnSerializing(StreamingContext ctx)
		{
		}

		// Token: 0x060011CF RID: 4559 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CF")]
		[Address(RVA = "0xD2A970", Offset = "0xD29970", VA = "0x180D2A970")]
		internal void DeserializeEncoding(SerializationInfo info, StreamingContext context)
		{
		}

		// Token: 0x060011D0 RID: 4560 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011D0")]
		[Address(RVA = "0xD2CD50", Offset = "0xD2BD50", VA = "0x180D2CD50")]
		internal void SerializeEncoding(SerializationInfo info, StreamingContext context)
		{
		}

		// Token: 0x170001C3 RID: 451
		// (get) Token: 0x060011D1 RID: 4561 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C3")]
		private static object InternalSyncObject
		{
			[Token(Token = "0x60011D1")]
			[Address(RVA = "0xD2D5B0", Offset = "0xD2C5B0", VA = "0x180D2D5B0")]
			get
			{
				return null;
			}
		}

		/// <summary>Returns the encoding associated with the specified code page identifier.</summary>
		/// <param name="codepage">The code page identifier of the preferred encoding. Possible values are listed in the Code Page column of the table that appears in the <see cref="T:System.Text.Encoding" /> class topic.  
		///  -or-  
		///  0 (zero), to use the default encoding.</param>
		/// <returns>The encoding that is associated with the specified code page.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="codepage" /> is less than zero or greater than 65535.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="codepage" /> is not supported by the underlying platform.</exception>
		/// <exception cref="T:System.NotSupportedException">
		///   <paramref name="codepage" /> is not supported by the underlying platform.</exception>
		// Token: 0x060011D2 RID: 4562 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011D2")]
		[Address(RVA = "0xD2BC70", Offset = "0xD2AC70", VA = "0x180D2BC70")]
		public static Encoding GetEncoding(int codepage)
		{
			return null;
		}

		/// <summary>Returns the encoding associated with the specified code page name.</summary>
		/// <param name="name">The code page name of the preferred encoding. Any value returned by the <see cref="P:System.Text.Encoding.WebName" /> property is valid. Possible values are listed in the Name column of the table that appears in the <see cref="T:System.Text.Encoding" /> class topic.</param>
		/// <returns>The encoding  associated with the specified code page.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="name" /> is not a valid code page name.  
		/// -or-  
		/// The code page indicated by <paramref name="name" /> is not supported by the underlying platform.</exception>
		// Token: 0x060011D3 RID: 4563 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011D3")]
		[Address(RVA = "0xD2C8D0", Offset = "0xD2B8D0", VA = "0x180D2C8D0")]
		public static Encoding GetEncoding(string name)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, returns a sequence of bytes that specifies the encoding used.</summary>
		/// <returns>A byte array containing a sequence of bytes that specifies the encoding used.  
		///  -or-  
		///  A byte array of length zero, if a preamble is not required.</returns>
		// Token: 0x060011D4 RID: 4564 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011D4")]
		[Address(RVA = "0xD2CAC0", Offset = "0xD2BAC0", VA = "0x180D2CAC0", Slot = "6")]
		public virtual byte[] GetPreamble()
		{
			return null;
		}

		// Token: 0x060011D5 RID: 4565 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011D5")]
		[Address(RVA = "0xD2BAA0", Offset = "0xD2AAA0", VA = "0x180D2BAA0")]
		private void GetDataItem()
		{
		}

		/// <summary>When overridden in a derived class, gets a name for the current encoding that can be used with mail agent body tags.</summary>
		/// <returns>A name for the current <see cref="T:System.Text.Encoding" /> that can be used with mail agent body tags.  
		///  -or-  
		///  An empty string (""), if the current <see cref="T:System.Text.Encoding" /> cannot be used.</returns>
		// Token: 0x170001C4 RID: 452
		// (get) Token: 0x060011D6 RID: 4566 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C4")]
		public virtual string BodyName
		{
			[Token(Token = "0x60011D6")]
			[Address(RVA = "0xD2D450", Offset = "0xD2C450", VA = "0x180D2D450", Slot = "7")]
			get
			{
				return null;
			}
		}

		/// <summary>When overridden in a derived class, gets the human-readable description of the current encoding.</summary>
		/// <returns>The human-readable description of the current <see cref="T:System.Text.Encoding" />.</returns>
		// Token: 0x170001C5 RID: 453
		// (get) Token: 0x060011D7 RID: 4567 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C5")]
		public virtual string EncodingName
		{
			[Token(Token = "0x60011D7")]
			[Address(RVA = "0xD2D560", Offset = "0xD2C560", VA = "0x180D2D560", Slot = "8")]
			get
			{
				return null;
			}
		}

		/// <summary>When overridden in a derived class, gets a name for the current encoding that can be used with mail agent header tags.</summary>
		/// <returns>A name for the current <see cref="T:System.Text.Encoding" /> to use with mail agent header tags.  
		///  -or-  
		///  An empty string (""), if the current <see cref="T:System.Text.Encoding" /> cannot be used.</returns>
		// Token: 0x170001C6 RID: 454
		// (get) Token: 0x060011D8 RID: 4568 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C6")]
		public virtual string HeaderName
		{
			[Token(Token = "0x60011D8")]
			[Address(RVA = "0xD2D570", Offset = "0xD2C570", VA = "0x180D2D570", Slot = "9")]
			get
			{
				return null;
			}
		}

		/// <summary>When overridden in a derived class, gets the name registered with the Internet Assigned Numbers Authority (IANA) for the current encoding.</summary>
		/// <returns>The IANA name for the current <see cref="T:System.Text.Encoding" />.</returns>
		// Token: 0x170001C7 RID: 455
		// (get) Token: 0x060011D9 RID: 4569 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C7")]
		public virtual string WebName
		{
			[Token(Token = "0x60011D9")]
			[Address(RVA = "0xD2D940", Offset = "0xD2C940", VA = "0x180D2D940", Slot = "10")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets or sets the <see cref="T:System.Text.EncoderFallback" /> object for the current <see cref="T:System.Text.Encoding" /> object.</summary>
		/// <returns>The encoder fallback object for the current <see cref="T:System.Text.Encoding" /> object.</returns>
		/// <exception cref="T:System.ArgumentNullException">The value in a set operation is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">A value cannot be assigned in a set operation because the current <see cref="T:System.Text.Encoding" /> object is read-only.</exception>
		// Token: 0x170001C8 RID: 456
		// (get) Token: 0x060011DA RID: 4570 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x060011DB RID: 4571 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001C8")]
		[ComVisible(false)]
		public EncoderFallback EncoderFallback
		{
			[Token(Token = "0x60011DA")]
			[Address(RVA = "0x4157D0", Offset = "0x4147D0", VA = "0x1804157D0")]
			get
			{
				return null;
			}
			[Token(Token = "0x60011DB")]
			[Address(RVA = "0xD2DA40", Offset = "0xD2CA40", VA = "0x180D2DA40")]
			set
			{
			}
		}

		/// <summary>Gets or sets the <see cref="T:System.Text.DecoderFallback" /> object for the current <see cref="T:System.Text.Encoding" /> object.</summary>
		/// <returns>The decoder fallback object for the current <see cref="T:System.Text.Encoding" /> object.</returns>
		/// <exception cref="T:System.ArgumentNullException">The value in a set operation is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidOperationException">A value cannot be assigned in a set operation because the current <see cref="T:System.Text.Encoding" /> object is read-only.</exception>
		// Token: 0x170001C9 RID: 457
		// (get) Token: 0x060011DC RID: 4572 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x060011DD RID: 4573 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001C9")]
		[ComVisible(false)]
		public DecoderFallback DecoderFallback
		{
			[Token(Token = "0x60011DC")]
			[Address(RVA = "0x4157E0", Offset = "0x4147E0", VA = "0x1804157E0")]
			get
			{
				return null;
			}
			[Token(Token = "0x60011DD")]
			[Address(RVA = "0xD2D980", Offset = "0xD2C980", VA = "0x180D2D980")]
			set
			{
			}
		}

		/// <summary>When overridden in a derived class, creates a shallow copy of the current <see cref="T:System.Text.Encoding" /> object.</summary>
		/// <returns>A copy of the current <see cref="T:System.Text.Encoding" /> object.</returns>
		// Token: 0x060011DE RID: 4574 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011DE")]
		[Address(RVA = "0xD2A880", Offset = "0xD29880", VA = "0x180D2A880", Slot = "11")]
		[ComVisible(false)]
		public virtual object Clone()
		{
			return null;
		}

		/// <summary>When overridden in a derived class, gets a value indicating whether the current encoding is read-only.</summary>
		/// <returns>
		///   <see langword="true" /> if the current <see cref="T:System.Text.Encoding" /> is read-only; otherwise, <see langword="false" />. The default is <see langword="true" />.</returns>
		// Token: 0x170001CA RID: 458
		// (get) Token: 0x060011DF RID: 4575 RVA: 0x0000DEF0 File Offset: 0x0000C0F0
		[Token(Token = "0x170001CA")]
		[ComVisible(false)]
		public bool IsReadOnly
		{
			[Token(Token = "0x60011DF")]
			[Address(RVA = "0x4700D0", Offset = "0x46F0D0", VA = "0x1804700D0")]
			get
			{
				return default(bool);
			}
		}

		/// <summary>Gets an encoding for the ASCII (7-bit) character set.</summary>
		/// <returns>An  encoding for the ASCII (7-bit) character set.</returns>
		// Token: 0x170001CB RID: 459
		// (get) Token: 0x060011E0 RID: 4576 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CB")]
		public static Encoding ASCII
		{
			[Token(Token = "0x60011E0")]
			[Address(RVA = "0xD2D2E0", Offset = "0xD2C2E0", VA = "0x180D2D2E0")]
			get
			{
				return null;
			}
		}

		// Token: 0x170001CC RID: 460
		// (get) Token: 0x060011E1 RID: 4577 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CC")]
		private static Encoding Latin1
		{
			[Token(Token = "0x60011E1")]
			[Address(RVA = "0xD2D640", Offset = "0xD2C640", VA = "0x180D2D640")]
			get
			{
				return null;
			}
		}

		/// <summary>When overridden in a derived class, calculates the number of bytes produced by encoding the characters in the specified string.</summary>
		/// <param name="s">The string containing the set of characters to encode.</param>
		/// <returns>The number of bytes produced by encoding the specified characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E2 RID: 4578 RVA: 0x0000DF08 File Offset: 0x0000C108
		[Token(Token = "0x60011E2")]
		[Address(RVA = "0xD2ADD0", Offset = "0xD29DD0", VA = "0x180D2ADD0", Slot = "12")]
		public virtual int GetByteCount(string s)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters from the specified character array.</summary>
		/// <param name="chars">The character array containing the set of characters to encode.</param>
		/// <param name="index">The index of the first character to encode.</param>
		/// <param name="count">The number of characters to encode.</param>
		/// <returns>The number of bytes produced by encoding the specified characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> or <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="chars" />.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E3 RID: 4579
		[Token(Token = "0x60011E3")]
		[Address(Slot = "13")]
		public abstract int GetByteCount(char[] chars, int index, int count);

		/// <summary>When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters starting at the specified character pointer.</summary>
		/// <param name="chars">A pointer to the first character to encode.</param>
		/// <param name="count">The number of characters to encode.</param>
		/// <returns>The number of bytes produced by encoding the specified characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is less than zero.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E4 RID: 4580 RVA: 0x0000DF20 File Offset: 0x0000C120
		[Token(Token = "0x60011E4")]
		[Address(RVA = "0xD2AEA0", Offset = "0xD29EA0", VA = "0x180D2AEA0", Slot = "14")]
		[ComVisible(false)]
		[CLSCompliant(false)]
		public unsafe virtual int GetByteCount(char* chars, int count)
		{
			return 0;
		}

		// Token: 0x060011E5 RID: 4581 RVA: 0x0000DF38 File Offset: 0x0000C138
		[Token(Token = "0x60011E5")]
		[Address(RVA = "0xD2AE80", Offset = "0xD29E80", VA = "0x180D2AE80", Slot = "15")]
		internal unsafe virtual int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, encodes all the characters in the specified character array into a sequence of bytes.</summary>
		/// <param name="chars">The character array containing the characters to encode.</param>
		/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E6 RID: 4582 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011E6")]
		[Address(RVA = "0xD2B4C0", Offset = "0xD2A4C0", VA = "0x180D2B4C0", Slot = "16")]
		public virtual byte[] GetBytes(char[] chars)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, encodes a set of characters from the specified character array into a sequence of bytes.</summary>
		/// <param name="chars">The character array containing the set of characters to encode.</param>
		/// <param name="index">The index of the first character to encode.</param>
		/// <param name="count">The number of characters to encode.</param>
		/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> or <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="chars" />.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E7 RID: 4583 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011E7")]
		[Address(RVA = "0xD2B3F0", Offset = "0xD2A3F0", VA = "0x180D2B3F0", Slot = "17")]
		public virtual byte[] GetBytes(char[] chars, int index, int count)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, encodes a set of characters from the specified character array into the specified byte array.</summary>
		/// <param name="chars">The character array containing the set of characters to encode.</param>
		/// <param name="charIndex">The index of the first character to encode.</param>
		/// <param name="charCount">The number of characters to encode.</param>
		/// <param name="bytes">The byte array to contain the resulting sequence of bytes.</param>
		/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes.</param>
		/// <returns>The actual number of bytes written into <paramref name="bytes" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="charIndex" /> or <paramref name="charCount" /> or <paramref name="byteIndex" /> is less than zero.  
		/// -or-  
		/// <paramref name="charIndex" /> and <paramref name="charCount" /> do not denote a valid range in <paramref name="chars" />.  
		/// -or-  
		/// <paramref name="byteIndex" /> is not a valid index in <paramref name="bytes" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="bytes" /> does not have enough capacity from <paramref name="byteIndex" /> to the end of the array to accommodate the resulting bytes.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E8 RID: 4584
		[Token(Token = "0x60011E8")]
		[Address(Slot = "18")]
		public abstract int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex);

		/// <summary>When overridden in a derived class, encodes all the characters in the specified string into a sequence of bytes.</summary>
		/// <param name="s">The string containing the characters to encode.</param>
		/// <returns>A byte array containing the results of encoding the specified set of characters.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011E9 RID: 4585 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011E9")]
		[Address(RVA = "0xD2B220", Offset = "0xD2A220", VA = "0x180D2B220", Slot = "19")]
		public virtual byte[] GetBytes(string s)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, encodes a set of characters from the specified string into the specified byte array.</summary>
		/// <param name="s">The string containing the set of characters to encode.</param>
		/// <param name="charIndex">The index of the first character to encode.</param>
		/// <param name="charCount">The number of characters to encode.</param>
		/// <param name="bytes">The byte array to contain the resulting sequence of bytes.</param>
		/// <param name="byteIndex">The index at which to start writing the resulting sequence of bytes.</param>
		/// <returns>The actual number of bytes written into <paramref name="bytes" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="charIndex" /> or <paramref name="charCount" /> or <paramref name="byteIndex" /> is less than zero.  
		/// -or-  
		/// <paramref name="charIndex" /> and <paramref name="charCount" /> do not denote a valid range in <paramref name="chars" />.  
		/// -or-  
		/// <paramref name="byteIndex" /> is not a valid index in <paramref name="bytes" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="bytes" /> does not have enough capacity from <paramref name="byteIndex" /> to the end of the array to accommodate the resulting bytes.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011EA RID: 4586 RVA: 0x0000DF50 File Offset: 0x0000C150
		[Token(Token = "0x60011EA")]
		[Address(RVA = "0xD2B310", Offset = "0xD2A310", VA = "0x180D2B310", Slot = "20")]
		public virtual int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			return 0;
		}

		// Token: 0x060011EB RID: 4587 RVA: 0x0000DF68 File Offset: 0x0000C168
		[Token(Token = "0x60011EB")]
		[Address(RVA = "0xD2B3D0", Offset = "0xD2A3D0", VA = "0x180D2B3D0", Slot = "21")]
		internal unsafe virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, encodes a set of characters starting at the specified character pointer into a sequence of bytes that are stored starting at the specified byte pointer.</summary>
		/// <param name="chars">A pointer to the first character to encode.</param>
		/// <param name="charCount">The number of characters to encode.</param>
		/// <param name="bytes">A pointer to the location at which to start writing the resulting sequence of bytes.</param>
		/// <param name="byteCount">The maximum number of bytes to write.</param>
		/// <returns>The actual number of bytes written at the location indicated by the <paramref name="bytes" /> parameter.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="charCount" /> or <paramref name="byteCount" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="byteCount" /> is less than the resulting number of bytes.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011EC RID: 4588 RVA: 0x0000DF80 File Offset: 0x0000C180
		[Token(Token = "0x60011EC")]
		[Address(RVA = "0xD2B000", Offset = "0xD2A000", VA = "0x180D2B000", Slot = "22")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe virtual int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, calculates the number of characters produced by decoding a sequence of bytes from the specified byte array.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <param name="index">The index of the first byte to decode.</param>
		/// <param name="count">The number of bytes to decode.</param>
		/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> or <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="bytes" />.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011ED RID: 4589
		[Token(Token = "0x60011ED")]
		[Address(Slot = "23")]
		public abstract int GetCharCount(byte[] bytes, int index, int count);

		/// <summary>When overridden in a derived class, calculates the number of characters produced by decoding a sequence of bytes starting at the specified byte pointer.</summary>
		/// <param name="bytes">A pointer to the first byte to decode.</param>
		/// <param name="count">The number of bytes to decode.</param>
		/// <returns>The number of characters produced by decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="count" /> is less than zero.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011EE RID: 4590 RVA: 0x0000DF98 File Offset: 0x0000C198
		[Token(Token = "0x60011EE")]
		[Address(RVA = "0xD2B570", Offset = "0xD2A570", VA = "0x180D2B570", Slot = "24")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe virtual int GetCharCount(byte* bytes, int count)
		{
			return 0;
		}

		// Token: 0x060011EF RID: 4591 RVA: 0x0000DFB0 File Offset: 0x0000C1B0
		[Token(Token = "0x60011EF")]
		[Address(RVA = "0xD2B6C0", Offset = "0xD2A6C0", VA = "0x180D2B6C0", Slot = "25")]
		internal unsafe virtual int GetCharCount(byte* bytes, int count, DecoderNLS decoder)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, decodes all the bytes in the specified byte array into a set of characters.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <returns>A character array containing the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011F0 RID: 4592 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011F0")]
		[Address(RVA = "0xD2B9F0", Offset = "0xD2A9F0", VA = "0x180D2B9F0", Slot = "26")]
		public virtual char[] GetChars(byte[] bytes)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, decodes a sequence of bytes from the specified byte array into a set of characters.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <param name="index">The index of the first byte to decode.</param>
		/// <param name="count">The number of bytes to decode.</param>
		/// <returns>A character array containing the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> or <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="bytes" />.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011F1 RID: 4593 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011F1")]
		[Address(RVA = "0xD2B6E0", Offset = "0xD2A6E0", VA = "0x180D2B6E0", Slot = "27")]
		public virtual char[] GetChars(byte[] bytes, int index, int count)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, decodes a sequence of bytes from the specified byte array into the specified character array.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <param name="byteIndex">The index of the first byte to decode.</param>
		/// <param name="byteCount">The number of bytes to decode.</param>
		/// <param name="chars">The character array to contain the resulting set of characters.</param>
		/// <param name="charIndex">The index at which to start writing the resulting set of characters.</param>
		/// <returns>The actual number of characters written into <paramref name="chars" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="byteIndex" /> or <paramref name="byteCount" /> or <paramref name="charIndex" /> is less than zero.  
		/// -or-  
		/// <paramref name="byteindex" /> and <paramref name="byteCount" /> do not denote a valid range in <paramref name="bytes" />.  
		/// -or-  
		/// <paramref name="charIndex" /> is not a valid index in <paramref name="chars" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="chars" /> does not have enough capacity from <paramref name="charIndex" /> to the end of the array to accommodate the resulting characters.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011F2 RID: 4594
		[Token(Token = "0x60011F2")]
		[Address(Slot = "28")]
		public abstract int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);

		/// <summary>When overridden in a derived class, decodes a sequence of bytes starting at the specified byte pointer into a set of characters that are stored starting at the specified character pointer.</summary>
		/// <param name="bytes">A pointer to the first byte to decode.</param>
		/// <param name="byteCount">The number of bytes to decode.</param>
		/// <param name="chars">A pointer to the location at which to start writing the resulting set of characters.</param>
		/// <param name="charCount">The maximum number of characters to write.</param>
		/// <returns>The actual number of characters written at the location indicated by the <paramref name="chars" /> parameter.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.  
		/// -or-  
		/// <paramref name="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="byteCount" /> or <paramref name="charCount" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="charCount" /> is less than the resulting number of characters.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011F3 RID: 4595 RVA: 0x0000DFC8 File Offset: 0x0000C1C8
		[Token(Token = "0x60011F3")]
		[Address(RVA = "0xD2B7B0", Offset = "0xD2A7B0", VA = "0x180D2B7B0", Slot = "29")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			return 0;
		}

		// Token: 0x060011F4 RID: 4596 RVA: 0x0000DFE0 File Offset: 0x0000C1E0
		[Token(Token = "0x60011F4")]
		[Address(RVA = "0xD2B9D0", Offset = "0xD2A9D0", VA = "0x180D2B9D0", Slot = "30")]
		internal unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS decoder)
		{
			return 0;
		}

		/// <summary>When overridden in a derived class, decodes a specified number of bytes starting at a specified address into a string.</summary>
		/// <param name="bytes">A pointer to a byte array.</param>
		/// <param name="byteCount">The number of bytes to decode.</param>
		/// <returns>A string that contains the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is a null pointer.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="byteCount" /> is less than zero.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A   fallback occurred (see Character Encoding in .NET for a complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011F5 RID: 4597 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011F5")]
		[Address(RVA = "0xD2CB20", Offset = "0xD2BB20", VA = "0x180D2CB20")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe string GetString(byte* bytes, int byteCount)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, gets the code page identifier of the current <see cref="T:System.Text.Encoding" />.</summary>
		/// <returns>The code page identifier of the current <see cref="T:System.Text.Encoding" />.</returns>
		// Token: 0x170001CD RID: 461
		// (get) Token: 0x060011F6 RID: 4598 RVA: 0x0000DFF8 File Offset: 0x0000C1F8
		[Token(Token = "0x170001CD")]
		public virtual int CodePage
		{
			[Token(Token = "0x60011F6")]
			[Address(RVA = "0x40F000", Offset = "0x40E000", VA = "0x18040F000", Slot = "31")]
			get
			{
				return 0;
			}
		}

		/// <summary>When overridden in a derived class, obtains a decoder that converts an encoded sequence of bytes into a sequence of characters.</summary>
		/// <returns>A <see cref="T:System.Text.Decoder" /> that converts an encoded sequence of bytes into a sequence of characters.</returns>
		// Token: 0x060011F7 RID: 4599 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011F7")]
		[Address(RVA = "0xD2BBB0", Offset = "0xD2ABB0", VA = "0x180D2BBB0", Slot = "32")]
		public virtual Decoder GetDecoder()
		{
			return null;
		}

		// Token: 0x060011F8 RID: 4600 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011F8")]
		[Address(RVA = "0xD2A910", Offset = "0xD29910", VA = "0x180D2A910")]
		private static Encoding CreateDefaultEncoding()
		{
			return null;
		}

		// Token: 0x060011F9 RID: 4601 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011F9")]
		[Address(RVA = "0xABE6B0", Offset = "0xABD6B0", VA = "0x180ABE6B0")]
		internal void setReadOnly(bool value = true)
		{
		}

		/// <summary>Gets the default encoding for this .NET implementation.</summary>
		/// <returns>The default encoding for this .NET implementation.</returns>
		// Token: 0x170001CE RID: 462
		// (get) Token: 0x060011FA RID: 4602 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CE")]
		public static Encoding Default
		{
			[Token(Token = "0x60011FA")]
			[Address(RVA = "0xD2D490", Offset = "0xD2C490", VA = "0x180D2D490")]
			get
			{
				return null;
			}
		}

		/// <summary>When overridden in a derived class, obtains an encoder that converts a sequence of Unicode characters into an encoded sequence of bytes.</summary>
		/// <returns>A <see cref="T:System.Text.Encoder" /> that converts a sequence of Unicode characters into an encoded sequence of bytes.</returns>
		// Token: 0x060011FB RID: 4603 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011FB")]
		[Address(RVA = "0xD2BC10", Offset = "0xD2AC10", VA = "0x180D2BC10", Slot = "33")]
		public virtual Encoder GetEncoder()
		{
			return null;
		}

		/// <summary>When overridden in a derived class, calculates the maximum number of bytes produced by encoding the specified number of characters.</summary>
		/// <param name="charCount">The number of characters to encode.</param>
		/// <returns>The maximum number of bytes produced by encoding the specified number of characters.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="charCount" /> is less than zero.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060011FC RID: 4604
		[Token(Token = "0x60011FC")]
		[Address(Slot = "34")]
		public abstract int GetMaxByteCount(int charCount);

		/// <summary>When overridden in a derived class, calculates the maximum number of characters produced by decoding the specified number of bytes.</summary>
		/// <param name="byteCount">The number of bytes to decode.</param>
		/// <returns>The maximum number of characters produced by decoding the specified number of bytes.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="byteCount" /> is less than zero.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011FD RID: 4605
		[Token(Token = "0x60011FD")]
		[Address(Slot = "35")]
		public abstract int GetMaxCharCount(int byteCount);

		/// <summary>When overridden in a derived class, decodes all the bytes in the specified byte array into a string.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <returns>A string that contains the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentException">The byte array contains invalid Unicode code points.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011FE RID: 4606 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011FE")]
		[Address(RVA = "0xD2CC10", Offset = "0xD2BC10", VA = "0x180D2CC10", Slot = "36")]
		public virtual string GetString(byte[] bytes)
		{
			return null;
		}

		/// <summary>When overridden in a derived class, decodes a sequence of bytes from the specified byte array into a string.</summary>
		/// <param name="bytes">The byte array containing the sequence of bytes to decode.</param>
		/// <param name="index">The index of the first byte to decode.</param>
		/// <param name="count">The number of bytes to decode.</param>
		/// <returns>A string that contains the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentException">The byte array contains invalid Unicode code points.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="index" /> or <paramref name="count" /> is less than zero.  
		/// -or-  
		/// <paramref name="index" /> and <paramref name="count" /> do not denote a valid range in <paramref name="bytes" />.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in .NET for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060011FF RID: 4607 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011FF")]
		[Address(RVA = "0xD2CCC0", Offset = "0xD2BCC0", VA = "0x180D2CCC0", Slot = "37")]
		public virtual string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		/// <summary>Gets an encoding for the UTF-16 format using the little endian byte order.</summary>
		/// <returns>An encoding for the UTF-16 format using the little endian byte order.</returns>
		// Token: 0x170001CF RID: 463
		// (get) Token: 0x06001200 RID: 4608 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CF")]
		public static Encoding Unicode
		{
			[Token(Token = "0x6001200")]
			[Address(RVA = "0xD2D8A0", Offset = "0xD2C8A0", VA = "0x180D2D8A0")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-16 format that uses the big endian byte order.</summary>
		/// <returns>An encoding object for the UTF-16 format that uses the big endian byte order.</returns>
		// Token: 0x170001D0 RID: 464
		// (get) Token: 0x06001201 RID: 4609 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001D0")]
		public static Encoding BigEndianUnicode
		{
			[Token(Token = "0x6001201")]
			[Address(RVA = "0xD2D3B0", Offset = "0xD2C3B0", VA = "0x180D2D3B0")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-7 format.</summary>
		/// <returns>An encoding for the UTF-7 format.</returns>
		// Token: 0x170001D1 RID: 465
		// (get) Token: 0x06001202 RID: 4610 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001D1")]
		public static Encoding UTF7
		{
			[Token(Token = "0x6001202")]
			[Address(RVA = "0xD2D780", Offset = "0xD2C780", VA = "0x180D2D780")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-8 format.</summary>
		/// <returns>An encoding for the UTF-8 format.</returns>
		// Token: 0x170001D2 RID: 466
		// (get) Token: 0x06001203 RID: 4611 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001D2")]
		public static Encoding UTF8
		{
			[Token(Token = "0x6001203")]
			[Address(RVA = "0xD2D810", Offset = "0xD2C810", VA = "0x180D2D810")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-32 format using the little endian byte order.</summary>
		/// <returns>An  encoding object for the UTF-32 format using the little endian byte order.</returns>
		// Token: 0x170001D3 RID: 467
		// (get) Token: 0x06001204 RID: 4612 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001D3")]
		public static Encoding UTF32
		{
			[Token(Token = "0x6001204")]
			[Address(RVA = "0xD2D6E0", Offset = "0xD2C6E0", VA = "0x180D2D6E0")]
			get
			{
				return null;
			}
		}

		/// <summary>Determines whether the specified <see cref="T:System.Object" /> is equal to the current instance.</summary>
		/// <param name="value">The <see cref="T:System.Object" /> to compare with the current instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is an instance of <see cref="T:System.Text.Encoding" /> and is equal to the current instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x06001205 RID: 4613 RVA: 0x0000E010 File Offset: 0x0000C210
		[Token(Token = "0x6001205")]
		[Address(RVA = "0xD2AC20", Offset = "0xD29C20", VA = "0x180D2AC20", Slot = "0")]
		public override bool Equals(object value)
		{
			return default(bool);
		}

		/// <summary>Returns the hash code for the current instance.</summary>
		/// <returns>The hash code for the current instance.</returns>
		// Token: 0x06001206 RID: 4614 RVA: 0x0000E028 File Offset: 0x0000C228
		[Token(Token = "0x6001206")]
		[Address(RVA = "0xD2CA50", Offset = "0xD2BA50", VA = "0x180D2CA50", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x06001207 RID: 4615 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001207")]
		[Address(RVA = "0xD2AD70", Offset = "0xD29D70", VA = "0x180D2AD70", Slot = "38")]
		internal virtual char[] GetBestFitUnicodeToBytesData()
		{
			return null;
		}

		// Token: 0x06001208 RID: 4616 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001208")]
		[Address(RVA = "0xD2AD10", Offset = "0xD29D10", VA = "0x180D2AD10", Slot = "39")]
		internal virtual char[] GetBestFitBytesToUnicodeData()
		{
			return null;
		}

		// Token: 0x06001209 RID: 4617 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001209")]
		[Address(RVA = "0xD2CF70", Offset = "0xD2BF70", VA = "0x180D2CF70")]
		internal void ThrowBytesOverflow()
		{
		}

		// Token: 0x0600120A RID: 4618 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600120A")]
		[Address(RVA = "0xD2CEF0", Offset = "0xD2BEF0", VA = "0x180D2CEF0")]
		internal void ThrowBytesOverflow(EncoderNLS encoder, bool nothingEncoded)
		{
		}

		// Token: 0x0600120B RID: 4619 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600120B")]
		[Address(RVA = "0xD2D0F0", Offset = "0xD2C0F0", VA = "0x180D2D0F0")]
		internal void ThrowCharsOverflow()
		{
		}

		// Token: 0x0600120C RID: 4620 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600120C")]
		[Address(RVA = "0xD2D070", Offset = "0xD2C070", VA = "0x180D2D070")]
		internal void ThrowCharsOverflow(DecoderNLS decoder, bool nothingDecoded)
		{
		}

		// Token: 0x0400091C RID: 2332
		[Token(Token = "0x400091C")]
		private static Encoding defaultEncoding;

		// Token: 0x0400091D RID: 2333
		[Token(Token = "0x400091D")]
		private static Encoding unicodeEncoding;

		// Token: 0x0400091E RID: 2334
		[Token(Token = "0x400091E")]
		private static Encoding bigEndianUnicode;

		// Token: 0x0400091F RID: 2335
		[Token(Token = "0x400091F")]
		private static Encoding utf7Encoding;

		// Token: 0x04000920 RID: 2336
		[Token(Token = "0x4000920")]
		private static Encoding utf8Encoding;

		// Token: 0x04000921 RID: 2337
		[Token(Token = "0x4000921")]
		private static Encoding utf32Encoding;

		// Token: 0x04000922 RID: 2338
		[Token(Token = "0x4000922")]
		private static Encoding asciiEncoding;

		// Token: 0x04000923 RID: 2339
		[Token(Token = "0x4000923")]
		private static Encoding latin1Encoding;

		// Token: 0x04000924 RID: 2340
		[Token(Token = "0x4000924")]
		private static Hashtable encodings;

		// Token: 0x04000925 RID: 2341
		[Token(Token = "0x4000925")]
		private const int MIMECONTF_MAILNEWS = 1;

		// Token: 0x04000926 RID: 2342
		[Token(Token = "0x4000926")]
		private const int MIMECONTF_BROWSER = 2;

		// Token: 0x04000927 RID: 2343
		[Token(Token = "0x4000927")]
		private const int MIMECONTF_SAVABLE_MAILNEWS = 256;

		// Token: 0x04000928 RID: 2344
		[Token(Token = "0x4000928")]
		private const int MIMECONTF_SAVABLE_BROWSER = 512;

		// Token: 0x04000929 RID: 2345
		[Token(Token = "0x4000929")]
		private const int CodePageDefault = 0;

		// Token: 0x0400092A RID: 2346
		[Token(Token = "0x400092A")]
		private const int CodePageNoOEM = 1;

		// Token: 0x0400092B RID: 2347
		[Token(Token = "0x400092B")]
		private const int CodePageNoMac = 2;

		// Token: 0x0400092C RID: 2348
		[Token(Token = "0x400092C")]
		private const int CodePageNoThread = 3;

		// Token: 0x0400092D RID: 2349
		[Token(Token = "0x400092D")]
		private const int CodePageNoSymbol = 42;

		// Token: 0x0400092E RID: 2350
		[Token(Token = "0x400092E")]
		private const int CodePageUnicode = 1200;

		// Token: 0x0400092F RID: 2351
		[Token(Token = "0x400092F")]
		private const int CodePageBigEndian = 1201;

		// Token: 0x04000930 RID: 2352
		[Token(Token = "0x4000930")]
		private const int CodePageWindows1252 = 1252;

		// Token: 0x04000931 RID: 2353
		[Token(Token = "0x4000931")]
		private const int CodePageMacGB2312 = 10008;

		// Token: 0x04000932 RID: 2354
		[Token(Token = "0x4000932")]
		private const int CodePageGB2312 = 20936;

		// Token: 0x04000933 RID: 2355
		[Token(Token = "0x4000933")]
		private const int CodePageMacKorean = 10003;

		// Token: 0x04000934 RID: 2356
		[Token(Token = "0x4000934")]
		private const int CodePageDLLKorean = 20949;

		// Token: 0x04000935 RID: 2357
		[Token(Token = "0x4000935")]
		private const int ISO2022JP = 50220;

		// Token: 0x04000936 RID: 2358
		[Token(Token = "0x4000936")]
		private const int ISO2022JPESC = 50221;

		// Token: 0x04000937 RID: 2359
		[Token(Token = "0x4000937")]
		private const int ISO2022JPSISO = 50222;

		// Token: 0x04000938 RID: 2360
		[Token(Token = "0x4000938")]
		private const int ISOKorean = 50225;

		// Token: 0x04000939 RID: 2361
		[Token(Token = "0x4000939")]
		private const int ISOSimplifiedCN = 50227;

		// Token: 0x0400093A RID: 2362
		[Token(Token = "0x400093A")]
		private const int EUCJP = 51932;

		// Token: 0x0400093B RID: 2363
		[Token(Token = "0x400093B")]
		private const int ChineseHZ = 52936;

		// Token: 0x0400093C RID: 2364
		[Token(Token = "0x400093C")]
		private const int DuplicateEUCCN = 51936;

		// Token: 0x0400093D RID: 2365
		[Token(Token = "0x400093D")]
		private const int EUCCN = 936;

		// Token: 0x0400093E RID: 2366
		[Token(Token = "0x400093E")]
		private const int EUCKR = 51949;

		// Token: 0x0400093F RID: 2367
		[Token(Token = "0x400093F")]
		internal const int CodePageASCII = 20127;

		// Token: 0x04000940 RID: 2368
		[Token(Token = "0x4000940")]
		internal const int ISO_8859_1 = 28591;

		// Token: 0x04000941 RID: 2369
		[Token(Token = "0x4000941")]
		private const int ISCIIAssemese = 57006;

		// Token: 0x04000942 RID: 2370
		[Token(Token = "0x4000942")]
		private const int ISCIIBengali = 57003;

		// Token: 0x04000943 RID: 2371
		[Token(Token = "0x4000943")]
		private const int ISCIIDevanagari = 57002;

		// Token: 0x04000944 RID: 2372
		[Token(Token = "0x4000944")]
		private const int ISCIIGujarathi = 57010;

		// Token: 0x04000945 RID: 2373
		[Token(Token = "0x4000945")]
		private const int ISCIIKannada = 57008;

		// Token: 0x04000946 RID: 2374
		[Token(Token = "0x4000946")]
		private const int ISCIIMalayalam = 57009;

		// Token: 0x04000947 RID: 2375
		[Token(Token = "0x4000947")]
		private const int ISCIIOriya = 57007;

		// Token: 0x04000948 RID: 2376
		[Token(Token = "0x4000948")]
		private const int ISCIIPanjabi = 57011;

		// Token: 0x04000949 RID: 2377
		[Token(Token = "0x4000949")]
		private const int ISCIITamil = 57004;

		// Token: 0x0400094A RID: 2378
		[Token(Token = "0x400094A")]
		private const int ISCIITelugu = 57005;

		// Token: 0x0400094B RID: 2379
		[Token(Token = "0x400094B")]
		private const int GB18030 = 54936;

		// Token: 0x0400094C RID: 2380
		[Token(Token = "0x400094C")]
		private const int ISO_8859_8I = 38598;

		// Token: 0x0400094D RID: 2381
		[Token(Token = "0x400094D")]
		private const int ISO_8859_8_Visual = 28598;

		// Token: 0x0400094E RID: 2382
		[Token(Token = "0x400094E")]
		private const int ENC50229 = 50229;

		// Token: 0x0400094F RID: 2383
		[Token(Token = "0x400094F")]
		private const int CodePageUTF7 = 65000;

		// Token: 0x04000950 RID: 2384
		[Token(Token = "0x4000950")]
		private const int CodePageUTF8 = 65001;

		// Token: 0x04000951 RID: 2385
		[Token(Token = "0x4000951")]
		private const int CodePageUTF32 = 12000;

		// Token: 0x04000952 RID: 2386
		[Token(Token = "0x4000952")]
		private const int CodePageUTF32BE = 12001;

		// Token: 0x04000953 RID: 2387
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
		[Token(Token = "0x4000953")]
		internal int m_codePage;

		// Token: 0x04000954 RID: 2388
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x4000954")]
		internal CodePageDataItem dataItem;

		// Token: 0x04000955 RID: 2389
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x4000955")]
		[NonSerialized]
		internal bool m_deserializedFromEverett;

		// Token: 0x04000956 RID: 2390
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x21")]
		[Token(Token = "0x4000956")]
		[OptionalField]
		private bool m_isReadOnly;

		// Token: 0x04000957 RID: 2391
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
		[Token(Token = "0x4000957")]
		[OptionalField]
		internal EncoderFallback encoderFallback;

		// Token: 0x04000958 RID: 2392
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
		[Token(Token = "0x4000958")]
		[OptionalField]
		internal DecoderFallback decoderFallback;

		// Token: 0x04000959 RID: 2393
		[Token(Token = "0x4000959")]
		private static object s_InternalSyncObject;

		// Token: 0x020001DB RID: 475
		[Token(Token = "0x20001DB")]
		[Serializable]
		internal class DefaultEncoder : Encoder, ISerializable, IObjectReference
		{
			// Token: 0x0600120D RID: 4621 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600120D")]
			[Address(RVA = "0xD24B60", Offset = "0xD23B60", VA = "0x180D24B60")]
			public DefaultEncoder(Encoding encoding)
			{
			}

			// Token: 0x0600120E RID: 4622 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600120E")]
			[Address(RVA = "0xD24DB0", Offset = "0xD23DB0", VA = "0x180D24DB0")]
			internal DefaultEncoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x0600120F RID: 4623 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x600120F")]
			[Address(RVA = "0xD24C50", Offset = "0xD23C50", VA = "0x180D24C50", Slot = "12")]
			public object GetRealObject(StreamingContext context)
			{
				return null;
			}

			// Token: 0x06001210 RID: 4624 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001210")]
			[Address(RVA = "0xD24D20", Offset = "0xD23D20", VA = "0x180D24D20", Slot = "11")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x06001211 RID: 4625 RVA: 0x0000E040 File Offset: 0x0000C240
			[Token(Token = "0x6001211")]
			[Address(RVA = "0xD24B90", Offset = "0xD23B90", VA = "0x180D24B90", Slot = "5")]
			public override int GetByteCount(char[] chars, int index, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x06001212 RID: 4626 RVA: 0x0000E058 File Offset: 0x0000C258
			[Token(Token = "0x6001212")]
			[Address(RVA = "0xD24BC0", Offset = "0xD23BC0", VA = "0x180D24BC0", Slot = "6")]
			public unsafe override int GetByteCount(char* chars, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x06001213 RID: 4627 RVA: 0x0000E070 File Offset: 0x0000C270
			[Token(Token = "0x6001213")]
			[Address(RVA = "0xD24BF0", Offset = "0xD23BF0", VA = "0x180D24BF0", Slot = "7")]
			public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
			{
				return 0;
			}

			// Token: 0x06001214 RID: 4628 RVA: 0x0000E088 File Offset: 0x0000C288
			[Token(Token = "0x6001214")]
			[Address(RVA = "0xD24C20", Offset = "0xD23C20", VA = "0x180D24C20", Slot = "8")]
			public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
			{
				return 0;
			}

			// Token: 0x0400095A RID: 2394
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400095A")]
			private Encoding m_encoding;

			// Token: 0x0400095B RID: 2395
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x400095B")]
			[NonSerialized]
			private bool m_hasInitializedEncoding;

			// Token: 0x0400095C RID: 2396
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x2A")]
			[Token(Token = "0x400095C")]
			[NonSerialized]
			internal char charLeftOver;
		}

		// Token: 0x020001DC RID: 476
		[Token(Token = "0x20001DC")]
		[Serializable]
		internal class DefaultDecoder : Decoder, ISerializable, IObjectReference
		{
			// Token: 0x06001215 RID: 4629 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001215")]
			[Address(RVA = "0xD24B60", Offset = "0xD23B60", VA = "0x180D24B60")]
			public DefaultDecoder(Encoding encoding)
			{
			}

			// Token: 0x06001216 RID: 4630 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001216")]
			[Address(RVA = "0xD24970", Offset = "0xD23970", VA = "0x180D24970")]
			internal DefaultDecoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x06001217 RID: 4631 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x6001217")]
			[Address(RVA = "0xD24890", Offset = "0xD23890", VA = "0x180D24890", Slot = "14")]
			public object GetRealObject(StreamingContext context)
			{
				return null;
			}

			// Token: 0x06001218 RID: 4632 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001218")]
			[Address(RVA = "0xD248E0", Offset = "0xD238E0", VA = "0x180D248E0", Slot = "13")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x06001219 RID: 4633 RVA: 0x0000E0A0 File Offset: 0x0000C2A0
			[Token(Token = "0x6001219")]
			[Address(RVA = "0x676200", Offset = "0x675200", VA = "0x180676200", Slot = "5")]
			public override int GetCharCount(byte[] bytes, int index, int count)
			{
				return 0;
			}

			// Token: 0x0600121A RID: 4634 RVA: 0x0000E0B8 File Offset: 0x0000C2B8
			[Token(Token = "0x600121A")]
			[Address(RVA = "0xD24800", Offset = "0xD23800", VA = "0x180D24800", Slot = "6")]
			public override int GetCharCount(byte[] bytes, int index, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x0600121B RID: 4635 RVA: 0x0000E0D0 File Offset: 0x0000C2D0
			[Token(Token = "0x600121B")]
			[Address(RVA = "0xD247D0", Offset = "0xD237D0", VA = "0x180D247D0", Slot = "7")]
			public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x0600121C RID: 4636 RVA: 0x0000E0E8 File Offset: 0x0000C2E8
			[Token(Token = "0x600121C")]
			[Address(RVA = "0xD23670", Offset = "0xD22670", VA = "0x180D23670", Slot = "8")]
			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
			{
				return 0;
			}

			// Token: 0x0600121D RID: 4637 RVA: 0x0000E100 File Offset: 0x0000C300
			[Token(Token = "0x600121D")]
			[Address(RVA = "0xD24860", Offset = "0xD23860", VA = "0x180D24860", Slot = "9")]
			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
			{
				return 0;
			}

			// Token: 0x0600121E RID: 4638 RVA: 0x0000E118 File Offset: 0x0000C318
			[Token(Token = "0x600121E")]
			[Address(RVA = "0xD24830", Offset = "0xD23830", VA = "0x180D24830", Slot = "10")]
			public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
			{
				return 0;
			}

			// Token: 0x0400095D RID: 2397
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400095D")]
			private Encoding m_encoding;

			// Token: 0x0400095E RID: 2398
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x400095E")]
			[NonSerialized]
			private bool m_hasInitializedEncoding;
		}

		// Token: 0x020001DD RID: 477
		[Token(Token = "0x20001DD")]
		internal class EncodingCharBuffer
		{
			// Token: 0x0600121F RID: 4639 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600121F")]
			[Address(RVA = "0xD288A0", Offset = "0xD278A0", VA = "0x180D288A0")]
			internal unsafe EncodingCharBuffer(Encoding enc, DecoderNLS decoder, char* charStart, int charCount, byte* byteStart, int byteCount)
			{
			}

			// Token: 0x06001220 RID: 4640 RVA: 0x0000E130 File Offset: 0x0000C330
			[Token(Token = "0x6001220")]
			[Address(RVA = "0xD28540", Offset = "0xD27540", VA = "0x180D28540")]
			internal bool AddChar(char ch, int numBytes)
			{
				return default(bool);
			}

			// Token: 0x06001221 RID: 4641 RVA: 0x0000E148 File Offset: 0x0000C348
			[Token(Token = "0x6001221")]
			[Address(RVA = "0xD285B0", Offset = "0xD275B0", VA = "0x180D285B0")]
			internal bool AddChar(char ch)
			{
				return default(bool);
			}

			// Token: 0x06001222 RID: 4642 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001222")]
			[Address(RVA = "0xD28620", Offset = "0xD27620", VA = "0x180D28620")]
			internal void AdjustBytes(int count)
			{
			}

			// Token: 0x170001D4 RID: 468
			// (get) Token: 0x06001223 RID: 4643 RVA: 0x0000E160 File Offset: 0x0000C360
			[Token(Token = "0x170001D4")]
			internal bool MoreData
			{
				[Token(Token = "0x6001223")]
				[Address(RVA = "0xD289C0", Offset = "0xD279C0", VA = "0x180D289C0")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x06001224 RID: 4644 RVA: 0x0000E178 File Offset: 0x0000C378
			[Token(Token = "0x6001224")]
			[Address(RVA = "0xD28880", Offset = "0xD27880", VA = "0x180D28880")]
			internal byte GetNextByte()
			{
				return 0;
			}

			// Token: 0x170001D5 RID: 469
			// (get) Token: 0x06001225 RID: 4645 RVA: 0x0000E190 File Offset: 0x0000C390
			[Token(Token = "0x170001D5")]
			internal int BytesUsed
			{
				[Token(Token = "0x6001225")]
				[Address(RVA = "0xD289B0", Offset = "0xD279B0", VA = "0x180D289B0")]
				get
				{
					return 0;
				}
			}

			// Token: 0x06001226 RID: 4646 RVA: 0x0000E1A8 File Offset: 0x0000C3A8
			[Token(Token = "0x6001226")]
			[Address(RVA = "0xD28730", Offset = "0xD27730", VA = "0x180D28730")]
			internal bool Fallback(byte fallbackByte)
			{
				return default(bool);
			}

			// Token: 0x06001227 RID: 4647 RVA: 0x0000E1C0 File Offset: 0x0000C3C0
			[Token(Token = "0x6001227")]
			[Address(RVA = "0xD28630", Offset = "0xD27630", VA = "0x180D28630")]
			internal bool Fallback(byte[] byteBuffer)
			{
				return default(bool);
			}

			// Token: 0x170001D6 RID: 470
			// (get) Token: 0x06001228 RID: 4648 RVA: 0x0000E1D8 File Offset: 0x0000C3D8
			[Token(Token = "0x170001D6")]
			internal int Count
			{
				[Token(Token = "0x6001228")]
				[Address(RVA = "0x471180", Offset = "0x470180", VA = "0x180471180")]
				get
				{
					return 0;
				}
			}

			// Token: 0x0400095F RID: 2399
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x400095F")]
			private unsafe char* chars;

			// Token: 0x04000960 RID: 2400
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x4000960")]
			private unsafe char* charStart;

			// Token: 0x04000961 RID: 2401
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4000961")]
			private unsafe char* charEnd;

			// Token: 0x04000962 RID: 2402
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000962")]
			private int charCountResult;

			// Token: 0x04000963 RID: 2403
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000963")]
			private Encoding enc;

			// Token: 0x04000964 RID: 2404
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x4000964")]
			private DecoderNLS decoder;

			// Token: 0x04000965 RID: 2405
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
			[Token(Token = "0x4000965")]
			private unsafe byte* byteStart;

			// Token: 0x04000966 RID: 2406
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
			[Token(Token = "0x4000966")]
			private unsafe byte* byteEnd;

			// Token: 0x04000967 RID: 2407
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
			[Token(Token = "0x4000967")]
			private unsafe byte* bytes;

			// Token: 0x04000968 RID: 2408
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
			[Token(Token = "0x4000968")]
			private DecoderFallbackBuffer fallbackBuffer;
		}

		// Token: 0x020001DE RID: 478
		[Token(Token = "0x20001DE")]
		internal class EncodingByteBuffer
		{
			// Token: 0x06001229 RID: 4649 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001229")]
			[Address(RVA = "0xD28230", Offset = "0xD27230", VA = "0x180D28230")]
			internal unsafe EncodingByteBuffer(Encoding inEncoding, EncoderNLS inEncoder, byte* inByteStart, int inByteCount, char* inCharStart, int inCharCount)
			{
			}

			// Token: 0x0600122A RID: 4650 RVA: 0x0000E1F0 File Offset: 0x0000C3F0
			[Token(Token = "0x600122A")]
			[Address(RVA = "0xD280A0", Offset = "0xD270A0", VA = "0x180D280A0")]
			internal bool AddByte(byte b, int moreBytesExpected)
			{
				return default(bool);
			}

			// Token: 0x0600122B RID: 4651 RVA: 0x0000E208 File Offset: 0x0000C408
			[Token(Token = "0x600122B")]
			[Address(RVA = "0xD27F10", Offset = "0xD26F10", VA = "0x180D27F10")]
			internal bool AddByte(byte b1)
			{
				return default(bool);
			}

			// Token: 0x0600122C RID: 4652 RVA: 0x0000E220 File Offset: 0x0000C420
			[Token(Token = "0x600122C")]
			[Address(RVA = "0xD27F20", Offset = "0xD26F20", VA = "0x180D27F20")]
			internal bool AddByte(byte b1, byte b2)
			{
				return default(bool);
			}

			// Token: 0x0600122D RID: 4653 RVA: 0x0000E238 File Offset: 0x0000C438
			[Token(Token = "0x600122D")]
			[Address(RVA = "0xD27FD0", Offset = "0xD26FD0", VA = "0x180D27FD0")]
			internal bool AddByte(byte b1, byte b2, int moreBytesExpected)
			{
				return default(bool);
			}

			// Token: 0x0600122E RID: 4654 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600122E")]
			[Address(RVA = "0xD281B0", Offset = "0xD271B0", VA = "0x180D281B0")]
			internal void MovePrevious(bool bThrow)
			{
			}

			// Token: 0x170001D7 RID: 471
			// (get) Token: 0x0600122F RID: 4655 RVA: 0x0000E250 File Offset: 0x0000C450
			[Token(Token = "0x170001D7")]
			internal bool MoreData
			{
				[Token(Token = "0x600122F")]
				[Address(RVA = "0xD284F0", Offset = "0xD274F0", VA = "0x180D284F0")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x06001230 RID: 4656 RVA: 0x0000E268 File Offset: 0x0000C468
			[Token(Token = "0x6001230")]
			[Address(RVA = "0xD28140", Offset = "0xD27140", VA = "0x180D28140")]
			internal char GetNextChar()
			{
				return '\0';
			}

			// Token: 0x170001D8 RID: 472
			// (get) Token: 0x06001231 RID: 4657 RVA: 0x0000E280 File Offset: 0x0000C480
			[Token(Token = "0x170001D8")]
			internal int CharsUsed
			{
				[Token(Token = "0x6001231")]
				[Address(RVA = "0xD284D0", Offset = "0xD274D0", VA = "0x180D284D0")]
				get
				{
					return 0;
				}
			}

			// Token: 0x170001D9 RID: 473
			// (get) Token: 0x06001232 RID: 4658 RVA: 0x0000E298 File Offset: 0x0000C498
			[Token(Token = "0x170001D9")]
			internal int Count
			{
				[Token(Token = "0x6001232")]
				[Address(RVA = "0x678D20", Offset = "0x677D20", VA = "0x180678D20")]
				get
				{
					return 0;
				}
			}

			// Token: 0x04000969 RID: 2409
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4000969")]
			private unsafe byte* bytes;

			// Token: 0x0400096A RID: 2410
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x400096A")]
			private unsafe byte* byteStart;

			// Token: 0x0400096B RID: 2411
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400096B")]
			private unsafe byte* byteEnd;

			// Token: 0x0400096C RID: 2412
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x400096C")]
			private unsafe char* chars;

			// Token: 0x0400096D RID: 2413
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x400096D")]
			private unsafe char* charStart;

			// Token: 0x0400096E RID: 2414
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x400096E")]
			private unsafe char* charEnd;

			// Token: 0x0400096F RID: 2415
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
			[Token(Token = "0x400096F")]
			private int byteCountResult;

			// Token: 0x04000970 RID: 2416
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
			[Token(Token = "0x4000970")]
			private Encoding enc;

			// Token: 0x04000971 RID: 2417
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
			[Token(Token = "0x4000971")]
			private EncoderNLS encoder;

			// Token: 0x04000972 RID: 2418
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
			[Token(Token = "0x4000972")]
			internal EncoderFallbackBuffer fallbackBuffer;
		}
	}
}