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: 0x020001D3 RID: 467
	[Token(Token = "0x20001D3")]
	[ComVisible(true)]
	[Serializable]
	public abstract class Encoding : ICloneable
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.Encoding" /> class.</summary>
		// Token: 0x0600118C RID: 4492 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600118C")]
		[Address(RVA = "0x2F22180", Offset = "0x2F20F80", VA = "0x182F22180")]
		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: 0x0600118D RID: 4493 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600118D")]
		[Address(RVA = "0x2F220F0", Offset = "0x2F20EF0", VA = "0x182F220F0")]
		protected Encoding(int codePage)
		{
		}

		// Token: 0x0600118E RID: 4494 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600118E")]
		[Address(RVA = "0x2F21D50", Offset = "0x2F20B50", VA = "0x182F21D50", Slot = "5")]
		internal virtual void SetDefaultFallbacks()
		{
		}

		// Token: 0x0600118F RID: 4495 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600118F")]
		[Address(RVA = "0x2F21C30", Offset = "0x2F20A30", VA = "0x182F21C30")]
		internal void OnDeserializing()
		{
		}

		// Token: 0x06001190 RID: 4496 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001190")]
		[Address(RVA = "0x2F21BE0", Offset = "0x2F209E0", VA = "0x182F21BE0")]
		internal void OnDeserialized()
		{
		}

		// Token: 0x06001191 RID: 4497 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001191")]
		[Address(RVA = "0x2F21C30", Offset = "0x2F20A30", VA = "0x182F21C30")]
		[OnDeserializing]
		private void OnDeserializing(StreamingContext ctx)
		{
		}

		// Token: 0x06001192 RID: 4498 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001192")]
		[Address(RVA = "0x2F21BE0", Offset = "0x2F209E0", VA = "0x182F21BE0")]
		[OnDeserialized]
		private void OnDeserialized(StreamingContext ctx)
		{
		}

		// Token: 0x06001193 RID: 4499 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001193")]
		[Address(RVA = "0x1506400", Offset = "0x1505200", VA = "0x181506400")]
		[OnSerializing]
		private void OnSerializing(StreamingContext ctx)
		{
		}

		// Token: 0x06001194 RID: 4500 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001194")]
		[Address(RVA = "0x2F1F7A0", Offset = "0x2F1E5A0", VA = "0x182F1F7A0")]
		internal void DeserializeEncoding(SerializationInfo info, StreamingContext context)
		{
		}

		// Token: 0x06001195 RID: 4501 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001195")]
		[Address(RVA = "0x2F21C40", Offset = "0x2F20A40", VA = "0x182F21C40")]
		internal void SerializeEncoding(SerializationInfo info, StreamingContext context)
		{
		}

		// Token: 0x170001BB RID: 443
		// (get) Token: 0x06001196 RID: 4502 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001BB")]
		private static object InternalSyncObject
		{
			[Token(Token = "0x6001196")]
			[Address(RVA = "0x2F22470", Offset = "0x2F21270", VA = "0x182F22470")]
			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: 0x06001197 RID: 4503 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001197")]
		[Address(RVA = "0x2F20AA0", Offset = "0x2F1F8A0", VA = "0x182F20AA0")]
		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: 0x06001198 RID: 4504 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001198")]
		[Address(RVA = "0x2F217C0", Offset = "0x2F205C0", VA = "0x182F217C0")]
		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: 0x06001199 RID: 4505 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001199")]
		[Address(RVA = "0x2F219B0", Offset = "0x2F207B0", VA = "0x182F219B0", Slot = "6")]
		public virtual byte[] GetPreamble()
		{
			return null;
		}

		// Token: 0x0600119A RID: 4506 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600119A")]
		[Address(RVA = "0x2F208D0", Offset = "0x2F1F6D0", VA = "0x182F208D0")]
		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: 0x170001BC RID: 444
		// (get) Token: 0x0600119B RID: 4507 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001BC")]
		public virtual string BodyName
		{
			[Token(Token = "0x600119B")]
			[Address(RVA = "0x2F22310", Offset = "0x2F21110", VA = "0x182F22310", 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: 0x170001BD RID: 445
		// (get) Token: 0x0600119C RID: 4508 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001BD")]
		public virtual string EncodingName
		{
			[Token(Token = "0x600119C")]
			[Address(RVA = "0x2F22420", Offset = "0x2F21220", VA = "0x182F22420", 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: 0x170001BE RID: 446
		// (get) Token: 0x0600119D RID: 4509 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001BE")]
		public virtual string HeaderName
		{
			[Token(Token = "0x600119D")]
			[Address(RVA = "0x2F22430", Offset = "0x2F21230", VA = "0x182F22430", 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: 0x170001BF RID: 447
		// (get) Token: 0x0600119E RID: 4510 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001BF")]
		public virtual string WebName
		{
			[Token(Token = "0x600119E")]
			[Address(RVA = "0x2F22860", Offset = "0x2F21660", VA = "0x182F22860", 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: 0x170001C0 RID: 448
		// (get) Token: 0x0600119F RID: 4511 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x060011A0 RID: 4512 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001C0")]
		[ComVisible(false)]
		public EncoderFallback EncoderFallback
		{
			[Token(Token = "0x600119F")]
			[Address(RVA = "0x3F63E0", Offset = "0x3F51E0", VA = "0x1803F63E0")]
			get
			{
				return null;
			}
			[Token(Token = "0x60011A0")]
			[Address(RVA = "0x2F22960", Offset = "0x2F21760", VA = "0x182F22960")]
			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: 0x170001C1 RID: 449
		// (get) Token: 0x060011A1 RID: 4513 RVA: 0x00002082 File Offset: 0x00000282
		// (set) Token: 0x060011A2 RID: 4514 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x170001C1")]
		[ComVisible(false)]
		public DecoderFallback DecoderFallback
		{
			[Token(Token = "0x60011A1")]
			[Address(RVA = "0x3FA180", Offset = "0x3F8F80", VA = "0x1803FA180")]
			get
			{
				return null;
			}
			[Token(Token = "0x60011A2")]
			[Address(RVA = "0x2F228A0", Offset = "0x2F216A0", VA = "0x182F228A0")]
			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: 0x060011A3 RID: 4515 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011A3")]
		[Address(RVA = "0x2F1F6B0", Offset = "0x2F1E4B0", VA = "0x182F1F6B0", 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: 0x170001C2 RID: 450
		// (get) Token: 0x060011A4 RID: 4516 RVA: 0x0000DBC0 File Offset: 0x0000BDC0
		[Token(Token = "0x170001C2")]
		[ComVisible(false)]
		public bool IsReadOnly
		{
			[Token(Token = "0x60011A4")]
			[Address(RVA = "0x41ED50", Offset = "0x41DB50", VA = "0x18041ED50")]
			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: 0x170001C3 RID: 451
		// (get) Token: 0x060011A5 RID: 4517 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C3")]
		public static Encoding ASCII
		{
			[Token(Token = "0x60011A5")]
			[Address(RVA = "0x2F221E0", Offset = "0x2F20FE0", VA = "0x182F221E0")]
			get
			{
				return null;
			}
		}

		// Token: 0x170001C4 RID: 452
		// (get) Token: 0x060011A6 RID: 4518 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C4")]
		private static Encoding Latin1
		{
			[Token(Token = "0x60011A6")]
			[Address(RVA = "0x2F22500", Offset = "0x2F21300", VA = "0x182F22500")]
			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: 0x060011A7 RID: 4519 RVA: 0x0000DBD8 File Offset: 0x0000BDD8
		[Token(Token = "0x60011A7")]
		[Address(RVA = "0x2F1FC00", Offset = "0x2F1EA00", VA = "0x182F1FC00", 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: 0x060011A8 RID: 4520
		[Token(Token = "0x60011A8")]
		[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: 0x060011A9 RID: 4521 RVA: 0x0000DBF0 File Offset: 0x0000BDF0
		[Token(Token = "0x60011A9")]
		[Address(RVA = "0x2F1FCD0", Offset = "0x2F1EAD0", VA = "0x182F1FCD0", Slot = "14")]
		[ComVisible(false)]
		[CLSCompliant(false)]
		public unsafe virtual int GetByteCount(char* chars, int count)
		{
			return 0;
		}

		// Token: 0x060011AA RID: 4522 RVA: 0x0000DC08 File Offset: 0x0000BE08
		[Token(Token = "0x60011AA")]
		[Address(RVA = "0x2F1FCB0", Offset = "0x2F1EAB0", VA = "0x182F1FCB0", 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: 0x060011AB RID: 4523 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011AB")]
		[Address(RVA = "0x2F202F0", Offset = "0x2F1F0F0", VA = "0x182F202F0", 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: 0x060011AC RID: 4524 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011AC")]
		[Address(RVA = "0x2F20220", Offset = "0x2F1F020", VA = "0x182F20220", 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: 0x060011AD RID: 4525
		[Token(Token = "0x60011AD")]
		[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: 0x060011AE RID: 4526 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011AE")]
		[Address(RVA = "0x2F20050", Offset = "0x2F1EE50", VA = "0x182F20050", 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: 0x060011AF RID: 4527 RVA: 0x0000DC20 File Offset: 0x0000BE20
		[Token(Token = "0x60011AF")]
		[Address(RVA = "0x2F20140", Offset = "0x2F1EF40", VA = "0x182F20140", Slot = "20")]
		public virtual int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			return 0;
		}

		// Token: 0x060011B0 RID: 4528 RVA: 0x0000DC38 File Offset: 0x0000BE38
		[Token(Token = "0x60011B0")]
		[Address(RVA = "0x2F20200", Offset = "0x2F1F000", VA = "0x182F20200", 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: 0x060011B1 RID: 4529 RVA: 0x0000DC50 File Offset: 0x0000BE50
		[Token(Token = "0x60011B1")]
		[Address(RVA = "0x2F1FE30", Offset = "0x2F1EC30", VA = "0x182F1FE30", 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: 0x060011B2 RID: 4530
		[Token(Token = "0x60011B2")]
		[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: 0x060011B3 RID: 4531 RVA: 0x0000DC68 File Offset: 0x0000BE68
		[Token(Token = "0x60011B3")]
		[Address(RVA = "0x2F203A0", Offset = "0x2F1F1A0", VA = "0x182F203A0", Slot = "24")]
		[ComVisible(false)]
		[CLSCompliant(false)]
		public unsafe virtual int GetCharCount(byte* bytes, int count)
		{
			return 0;
		}

		// Token: 0x060011B4 RID: 4532 RVA: 0x0000DC80 File Offset: 0x0000BE80
		[Token(Token = "0x60011B4")]
		[Address(RVA = "0x2F204F0", Offset = "0x2F1F2F0", VA = "0x182F204F0", 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: 0x060011B5 RID: 4533 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011B5")]
		[Address(RVA = "0x2F20820", Offset = "0x2F1F620", VA = "0x182F20820", 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: 0x060011B6 RID: 4534 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011B6")]
		[Address(RVA = "0x2F20510", Offset = "0x2F1F310", VA = "0x182F20510", 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: 0x060011B7 RID: 4535
		[Token(Token = "0x60011B7")]
		[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: 0x060011B8 RID: 4536 RVA: 0x0000DC98 File Offset: 0x0000BE98
		[Token(Token = "0x60011B8")]
		[Address(RVA = "0x2F205E0", Offset = "0x2F1F3E0", VA = "0x182F205E0", Slot = "29")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe virtual int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			return 0;
		}

		// Token: 0x060011B9 RID: 4537 RVA: 0x0000DCB0 File Offset: 0x0000BEB0
		[Token(Token = "0x60011B9")]
		[Address(RVA = "0x2F20800", Offset = "0x2F1F600", VA = "0x182F20800", 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: 0x060011BA RID: 4538 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011BA")]
		[Address(RVA = "0x2F21A10", Offset = "0x2F20810", VA = "0x182F21A10")]
		[ComVisible(false)]
		[CLSCompliant(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: 0x170001C5 RID: 453
		// (get) Token: 0x060011BB RID: 4539 RVA: 0x0000DCC8 File Offset: 0x0000BEC8
		[Token(Token = "0x170001C5")]
		public virtual int CodePage
		{
			[Token(Token = "0x60011BB")]
			[Address(RVA = "0x3FA560", Offset = "0x3F9360", VA = "0x1803FA560", 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: 0x060011BC RID: 4540 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011BC")]
		[Address(RVA = "0x2F209E0", Offset = "0x2F1F7E0", VA = "0x182F209E0", Slot = "32")]
		public virtual Decoder GetDecoder()
		{
			return null;
		}

		// Token: 0x060011BD RID: 4541 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011BD")]
		[Address(RVA = "0x2F1F740", Offset = "0x2F1E540", VA = "0x182F1F740")]
		private static Encoding CreateDefaultEncoding()
		{
			return null;
		}

		// Token: 0x060011BE RID: 4542 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011BE")]
		[Address(RVA = "0x41EF90", Offset = "0x41DD90", VA = "0x18041EF90")]
		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: 0x170001C6 RID: 454
		// (get) Token: 0x060011BF RID: 4543 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C6")]
		public static Encoding Default
		{
			[Token(Token = "0x60011BF")]
			[Address(RVA = "0x2F22350", Offset = "0x2F21150", VA = "0x182F22350")]
			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: 0x060011C0 RID: 4544 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011C0")]
		[Address(RVA = "0x2F20A40", Offset = "0x2F1F840", VA = "0x182F20A40", 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: 0x060011C1 RID: 4545
		[Token(Token = "0x60011C1")]
		[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: 0x060011C2 RID: 4546
		[Token(Token = "0x60011C2")]
		[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: 0x060011C3 RID: 4547 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011C3")]
		[Address(RVA = "0x2F21B00", Offset = "0x2F20900", VA = "0x182F21B00", 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: 0x060011C4 RID: 4548 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011C4")]
		[Address(RVA = "0x2F21BB0", Offset = "0x2F209B0", VA = "0x182F21BB0", 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: 0x170001C7 RID: 455
		// (get) Token: 0x060011C5 RID: 4549 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C7")]
		public static Encoding Unicode
		{
			[Token(Token = "0x60011C5")]
			[Address(RVA = "0x2F227C0", Offset = "0x2F215C0", VA = "0x182F227C0")]
			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: 0x170001C8 RID: 456
		// (get) Token: 0x060011C6 RID: 4550 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C8")]
		public static Encoding BigEndianUnicode
		{
			[Token(Token = "0x60011C6")]
			[Address(RVA = "0x2F22270", Offset = "0x2F21070", VA = "0x182F22270")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-7 format.</summary>
		/// <returns>An encoding for the UTF-7 format.</returns>
		// Token: 0x170001C9 RID: 457
		// (get) Token: 0x060011C7 RID: 4551 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001C9")]
		public static Encoding UTF7
		{
			[Token(Token = "0x60011C7")]
			[Address(RVA = "0x2F22650", Offset = "0x2F21450", VA = "0x182F22650")]
			get
			{
				return null;
			}
		}

		/// <summary>Gets an encoding for the UTF-8 format.</summary>
		/// <returns>An encoding for the UTF-8 format.</returns>
		// Token: 0x170001CA RID: 458
		// (get) Token: 0x060011C8 RID: 4552 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CA")]
		public static Encoding UTF8
		{
			[Token(Token = "0x60011C8")]
			[Address(RVA = "0x2F22730", Offset = "0x2F21530", VA = "0x182F22730")]
			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: 0x170001CB RID: 459
		// (get) Token: 0x060011C9 RID: 4553 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x170001CB")]
		public static Encoding UTF32
		{
			[Token(Token = "0x60011C9")]
			[Address(RVA = "0x2F225A0", Offset = "0x2F213A0", VA = "0x182F225A0")]
			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: 0x060011CA RID: 4554 RVA: 0x0000DCE0 File Offset: 0x0000BEE0
		[Token(Token = "0x60011CA")]
		[Address(RVA = "0x2F1FA50", Offset = "0x2F1E850", VA = "0x182F1FA50", 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: 0x060011CB RID: 4555 RVA: 0x0000DCF8 File Offset: 0x0000BEF8
		[Token(Token = "0x60011CB")]
		[Address(RVA = "0x2F21940", Offset = "0x2F20740", VA = "0x182F21940", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x060011CC RID: 4556 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011CC")]
		[Address(RVA = "0x2F1FBA0", Offset = "0x2F1E9A0", VA = "0x182F1FBA0", Slot = "38")]
		internal virtual char[] GetBestFitUnicodeToBytesData()
		{
			return null;
		}

		// Token: 0x060011CD RID: 4557 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60011CD")]
		[Address(RVA = "0x2F1FB40", Offset = "0x2F1E940", VA = "0x182F1FB40", Slot = "39")]
		internal virtual char[] GetBestFitBytesToUnicodeData()
		{
			return null;
		}

		// Token: 0x060011CE RID: 4558 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CE")]
		[Address(RVA = "0x2F21E60", Offset = "0x2F20C60", VA = "0x182F21E60")]
		internal void ThrowBytesOverflow()
		{
		}

		// Token: 0x060011CF RID: 4559 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011CF")]
		[Address(RVA = "0x2F21DE0", Offset = "0x2F20BE0", VA = "0x182F21DE0")]
		internal void ThrowBytesOverflow(EncoderNLS encoder, bool nothingEncoded)
		{
		}

		// Token: 0x060011D0 RID: 4560 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011D0")]
		[Address(RVA = "0x2F21FF0", Offset = "0x2F20DF0", VA = "0x182F21FF0")]
		internal void ThrowCharsOverflow()
		{
		}

		// Token: 0x060011D1 RID: 4561 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60011D1")]
		[Address(RVA = "0x2F21F60", Offset = "0x2F20D60", VA = "0x182F21F60")]
		internal void ThrowCharsOverflow(DecoderNLS decoder, bool nothingDecoded)
		{
		}

		// Token: 0x04000912 RID: 2322
		[Token(Token = "0x4000912")]
		private static Encoding defaultEncoding;

		// Token: 0x04000913 RID: 2323
		[Token(Token = "0x4000913")]
		private static Encoding unicodeEncoding;

		// Token: 0x04000914 RID: 2324
		[Token(Token = "0x4000914")]
		private static Encoding bigEndianUnicode;

		// Token: 0x04000915 RID: 2325
		[Token(Token = "0x4000915")]
		private static Encoding utf7Encoding;

		// Token: 0x04000916 RID: 2326
		[Token(Token = "0x4000916")]
		private static Encoding utf8Encoding;

		// Token: 0x04000917 RID: 2327
		[Token(Token = "0x4000917")]
		private static Encoding utf32Encoding;

		// Token: 0x04000918 RID: 2328
		[Token(Token = "0x4000918")]
		private static Encoding asciiEncoding;

		// Token: 0x04000919 RID: 2329
		[Token(Token = "0x4000919")]
		private static Encoding latin1Encoding;

		// Token: 0x0400091A RID: 2330
		[Token(Token = "0x400091A")]
		private static Hashtable encodings;

		// Token: 0x0400091B RID: 2331
		[Token(Token = "0x400091B")]
		private const int MIMECONTF_MAILNEWS = 1;

		// Token: 0x0400091C RID: 2332
		[Token(Token = "0x400091C")]
		private const int MIMECONTF_BROWSER = 2;

		// Token: 0x0400091D RID: 2333
		[Token(Token = "0x400091D")]
		private const int MIMECONTF_SAVABLE_MAILNEWS = 256;

		// Token: 0x0400091E RID: 2334
		[Token(Token = "0x400091E")]
		private const int MIMECONTF_SAVABLE_BROWSER = 512;

		// Token: 0x0400091F RID: 2335
		[Token(Token = "0x400091F")]
		private const int CodePageDefault = 0;

		// Token: 0x04000920 RID: 2336
		[Token(Token = "0x4000920")]
		private const int CodePageNoOEM = 1;

		// Token: 0x04000921 RID: 2337
		[Token(Token = "0x4000921")]
		private const int CodePageNoMac = 2;

		// Token: 0x04000922 RID: 2338
		[Token(Token = "0x4000922")]
		private const int CodePageNoThread = 3;

		// Token: 0x04000923 RID: 2339
		[Token(Token = "0x4000923")]
		private const int CodePageNoSymbol = 42;

		// Token: 0x04000924 RID: 2340
		[Token(Token = "0x4000924")]
		private const int CodePageUnicode = 1200;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x04000935 RID: 2357
		[Token(Token = "0x4000935")]
		internal const int CodePageASCII = 20127;

		// Token: 0x04000936 RID: 2358
		[Token(Token = "0x4000936")]
		internal const int ISO_8859_1 = 28591;

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

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

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

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

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

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

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

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

		// Token: 0x0400093F RID: 2367
		[Token(Token = "0x400093F")]
		private const int ISCIITamil = 57004;

		// Token: 0x04000940 RID: 2368
		[Token(Token = "0x4000940")]
		private const int ISCIITelugu = 57005;

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

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

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

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

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

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

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

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

		// Token: 0x04000949 RID: 2377
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
		[Token(Token = "0x4000949")]
		internal int m_codePage;

		// Token: 0x0400094A RID: 2378
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
		[Token(Token = "0x400094A")]
		internal CodePageDataItem dataItem;

		// Token: 0x0400094B RID: 2379
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
		[Token(Token = "0x400094B")]
		[NonSerialized]
		internal bool m_deserializedFromEverett;

		// Token: 0x0400094C RID: 2380
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x21")]
		[Token(Token = "0x400094C")]
		[OptionalField]
		private bool m_isReadOnly;

		// Token: 0x0400094D RID: 2381
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
		[Token(Token = "0x400094D")]
		[OptionalField]
		internal EncoderFallback encoderFallback;

		// Token: 0x0400094E RID: 2382
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
		[Token(Token = "0x400094E")]
		[OptionalField]
		internal DecoderFallback decoderFallback;

		// Token: 0x0400094F RID: 2383
		[Token(Token = "0x400094F")]
		private static object s_InternalSyncObject;

		// Token: 0x020001D4 RID: 468
		[Token(Token = "0x20001D4")]
		[Serializable]
		internal class DefaultEncoder : Encoder, ISerializable, IObjectReference
		{
			// Token: 0x060011D2 RID: 4562 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011D2")]
			[Address(RVA = "0x2F1A8B0", Offset = "0x2F196B0", VA = "0x182F1A8B0")]
			public DefaultEncoder(Encoding encoding)
			{
			}

			// Token: 0x060011D3 RID: 4563 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011D3")]
			[Address(RVA = "0x2F1A670", Offset = "0x2F19470", VA = "0x182F1A670")]
			internal DefaultEncoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060011D4 RID: 4564 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x60011D4")]
			[Address(RVA = "0x2F1A510", Offset = "0x2F19310", VA = "0x182F1A510", Slot = "10")]
			public object GetRealObject(StreamingContext context)
			{
				return null;
			}

			// Token: 0x060011D5 RID: 4565 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011D5")]
			[Address(RVA = "0x2F1A5E0", Offset = "0x2F193E0", VA = "0x182F1A5E0", Slot = "9")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060011D6 RID: 4566 RVA: 0x0000DD10 File Offset: 0x0000BF10
			[Token(Token = "0x60011D6")]
			[Address(RVA = "0x2F1A450", Offset = "0x2F19250", VA = "0x182F1A450", Slot = "5")]
			public override int GetByteCount(char[] chars, int index, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x060011D7 RID: 4567 RVA: 0x0000DD28 File Offset: 0x0000BF28
			[Token(Token = "0x60011D7")]
			[Address(RVA = "0x2F1A480", Offset = "0x2F19280", VA = "0x182F1A480", Slot = "6")]
			public unsafe override int GetByteCount(char* chars, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x060011D8 RID: 4568 RVA: 0x0000DD40 File Offset: 0x0000BF40
			[Token(Token = "0x60011D8")]
			[Address(RVA = "0x2F1A4B0", Offset = "0x2F192B0", VA = "0x182F1A4B0", Slot = "7")]
			public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex, bool flush)
			{
				return 0;
			}

			// Token: 0x060011D9 RID: 4569 RVA: 0x0000DD58 File Offset: 0x0000BF58
			[Token(Token = "0x60011D9")]
			[Address(RVA = "0x2F1A4E0", Offset = "0x2F192E0", VA = "0x182F1A4E0", Slot = "8")]
			public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
			{
				return 0;
			}

			// Token: 0x04000950 RID: 2384
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4000950")]
			private Encoding m_encoding;

			// Token: 0x04000951 RID: 2385
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000951")]
			[NonSerialized]
			private bool m_hasInitializedEncoding;

			// Token: 0x04000952 RID: 2386
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x2A")]
			[Token(Token = "0x4000952")]
			[NonSerialized]
			internal char charLeftOver;
		}

		// Token: 0x020001D5 RID: 469
		[Token(Token = "0x20001D5")]
		[Serializable]
		internal class DefaultDecoder : Decoder, ISerializable, IObjectReference
		{
			// Token: 0x060011DA RID: 4570 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011DA")]
			[Address(RVA = "0x2F1A420", Offset = "0x2F19220", VA = "0x182F1A420")]
			public DefaultDecoder(Encoding encoding)
			{
			}

			// Token: 0x060011DB RID: 4571 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011DB")]
			[Address(RVA = "0x2F1A230", Offset = "0x2F19030", VA = "0x182F1A230")]
			internal DefaultDecoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060011DC RID: 4572 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x60011DC")]
			[Address(RVA = "0x2F1A150", Offset = "0x2F18F50", VA = "0x182F1A150", Slot = "14")]
			public object GetRealObject(StreamingContext context)
			{
				return null;
			}

			// Token: 0x060011DD RID: 4573 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011DD")]
			[Address(RVA = "0x2F1A1A0", Offset = "0x2F18FA0", VA = "0x182F1A1A0", Slot = "13")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060011DE RID: 4574 RVA: 0x0000DD70 File Offset: 0x0000BF70
			[Token(Token = "0x60011DE")]
			[Address(RVA = "0x5C0860", Offset = "0x5BF660", VA = "0x1805C0860", Slot = "5")]
			public override int GetCharCount(byte[] bytes, int index, int count)
			{
				return 0;
			}

			// Token: 0x060011DF RID: 4575 RVA: 0x0000DD88 File Offset: 0x0000BF88
			[Token(Token = "0x60011DF")]
			[Address(RVA = "0x2F1A0C0", Offset = "0x2F18EC0", VA = "0x182F1A0C0", Slot = "6")]
			public override int GetCharCount(byte[] bytes, int index, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x060011E0 RID: 4576 RVA: 0x0000DDA0 File Offset: 0x0000BFA0
			[Token(Token = "0x60011E0")]
			[Address(RVA = "0x2F1A090", Offset = "0x2F18E90", VA = "0x182F1A090", Slot = "7")]
			public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
			{
				return 0;
			}

			// Token: 0x060011E1 RID: 4577 RVA: 0x0000DDB8 File Offset: 0x0000BFB8
			[Token(Token = "0x60011E1")]
			[Address(RVA = "0x2F196C0", Offset = "0x2F184C0", VA = "0x182F196C0", Slot = "8")]
			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
			{
				return 0;
			}

			// Token: 0x060011E2 RID: 4578 RVA: 0x0000DDD0 File Offset: 0x0000BFD0
			[Token(Token = "0x60011E2")]
			[Address(RVA = "0x2F1A120", Offset = "0x2F18F20", VA = "0x182F1A120", Slot = "9")]
			public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex, bool flush)
			{
				return 0;
			}

			// Token: 0x060011E3 RID: 4579 RVA: 0x0000DDE8 File Offset: 0x0000BFE8
			[Token(Token = "0x60011E3")]
			[Address(RVA = "0x2F1A0F0", Offset = "0x2F18EF0", VA = "0x182F1A0F0", Slot = "10")]
			public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, bool flush)
			{
				return 0;
			}

			// Token: 0x04000953 RID: 2387
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4000953")]
			private Encoding m_encoding;

			// Token: 0x04000954 RID: 2388
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000954")]
			[NonSerialized]
			private bool m_hasInitializedEncoding;
		}

		// Token: 0x020001D6 RID: 470
		[Token(Token = "0x20001D6")]
		internal class EncodingCharBuffer
		{
			// Token: 0x060011E4 RID: 4580 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011E4")]
			[Address(RVA = "0x2F1D710", Offset = "0x2F1C510", VA = "0x182F1D710")]
			internal unsafe EncodingCharBuffer(Encoding enc, DecoderNLS decoder, char* charStart, int charCount, byte* byteStart, int byteCount)
			{
			}

			// Token: 0x060011E5 RID: 4581 RVA: 0x0000DE00 File Offset: 0x0000C000
			[Token(Token = "0x60011E5")]
			[Address(RVA = "0x2F1D3B0", Offset = "0x2F1C1B0", VA = "0x182F1D3B0")]
			internal bool AddChar(char ch, int numBytes)
			{
				return default(bool);
			}

			// Token: 0x060011E6 RID: 4582 RVA: 0x0000DE18 File Offset: 0x0000C018
			[Token(Token = "0x60011E6")]
			[Address(RVA = "0x2F1D420", Offset = "0x2F1C220", VA = "0x182F1D420")]
			internal bool AddChar(char ch)
			{
				return default(bool);
			}

			// Token: 0x060011E7 RID: 4583 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011E7")]
			[Address(RVA = "0x2F1D490", Offset = "0x2F1C290", VA = "0x182F1D490")]
			internal void AdjustBytes(int count)
			{
			}

			// Token: 0x170001CC RID: 460
			// (get) Token: 0x060011E8 RID: 4584 RVA: 0x0000DE30 File Offset: 0x0000C030
			[Token(Token = "0x170001CC")]
			internal bool MoreData
			{
				[Token(Token = "0x60011E8")]
				[Address(RVA = "0x2F1D7F0", Offset = "0x2F1C5F0", VA = "0x182F1D7F0")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x060011E9 RID: 4585 RVA: 0x0000DE48 File Offset: 0x0000C048
			[Token(Token = "0x60011E9")]
			[Address(RVA = "0x2F1D6F0", Offset = "0x2F1C4F0", VA = "0x182F1D6F0")]
			internal byte GetNextByte()
			{
				return 0;
			}

			// Token: 0x170001CD RID: 461
			// (get) Token: 0x060011EA RID: 4586 RVA: 0x0000DE60 File Offset: 0x0000C060
			[Token(Token = "0x170001CD")]
			internal int BytesUsed
			{
				[Token(Token = "0x60011EA")]
				[Address(RVA = "0x2F1D7E0", Offset = "0x2F1C5E0", VA = "0x182F1D7E0")]
				get
				{
					return 0;
				}
			}

			// Token: 0x060011EB RID: 4587 RVA: 0x0000DE78 File Offset: 0x0000C078
			[Token(Token = "0x60011EB")]
			[Address(RVA = "0x2F1D5A0", Offset = "0x2F1C3A0", VA = "0x182F1D5A0")]
			internal bool Fallback(byte fallbackByte)
			{
				return default(bool);
			}

			// Token: 0x060011EC RID: 4588 RVA: 0x0000DE90 File Offset: 0x0000C090
			[Token(Token = "0x60011EC")]
			[Address(RVA = "0x2F1D4A0", Offset = "0x2F1C2A0", VA = "0x182F1D4A0")]
			internal bool Fallback(byte[] byteBuffer)
			{
				return default(bool);
			}

			// Token: 0x170001CE RID: 462
			// (get) Token: 0x060011ED RID: 4589 RVA: 0x0000DEA8 File Offset: 0x0000C0A8
			[Token(Token = "0x170001CE")]
			internal int Count
			{
				[Token(Token = "0x60011ED")]
				[Address(RVA = "0x42EE50", Offset = "0x42DC50", VA = "0x18042EE50")]
				get
				{
					return 0;
				}
			}

			// Token: 0x04000955 RID: 2389
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4000955")]
			private unsafe char* chars;

			// Token: 0x04000956 RID: 2390
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x4000956")]
			private unsafe char* charStart;

			// Token: 0x04000957 RID: 2391
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4000957")]
			private unsafe char* charEnd;

			// Token: 0x04000958 RID: 2392
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000958")]
			private int charCountResult;

			// Token: 0x04000959 RID: 2393
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000959")]
			private Encoding enc;

			// Token: 0x0400095A RID: 2394
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x400095A")]
			private DecoderNLS decoder;

			// Token: 0x0400095B RID: 2395
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
			[Token(Token = "0x400095B")]
			private unsafe byte* byteStart;

			// Token: 0x0400095C RID: 2396
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
			[Token(Token = "0x400095C")]
			private unsafe byte* byteEnd;

			// Token: 0x0400095D RID: 2397
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
			[Token(Token = "0x400095D")]
			private unsafe byte* bytes;

			// Token: 0x0400095E RID: 2398
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
			[Token(Token = "0x400095E")]
			private DecoderFallbackBuffer fallbackBuffer;
		}

		// Token: 0x020001D7 RID: 471
		[Token(Token = "0x20001D7")]
		internal class EncodingByteBuffer
		{
			// Token: 0x060011EE RID: 4590 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011EE")]
			[Address(RVA = "0x2F1D0A0", Offset = "0x2F1BEA0", VA = "0x182F1D0A0")]
			internal unsafe EncodingByteBuffer(Encoding inEncoding, EncoderNLS inEncoder, byte* inByteStart, int inByteCount, char* inCharStart, int inCharCount)
			{
			}

			// Token: 0x060011EF RID: 4591 RVA: 0x0000DEC0 File Offset: 0x0000C0C0
			[Token(Token = "0x60011EF")]
			[Address(RVA = "0x2F1CF10", Offset = "0x2F1BD10", VA = "0x182F1CF10")]
			internal bool AddByte(byte b, int moreBytesExpected)
			{
				return default(bool);
			}

			// Token: 0x060011F0 RID: 4592 RVA: 0x0000DED8 File Offset: 0x0000C0D8
			[Token(Token = "0x60011F0")]
			[Address(RVA = "0x2F1CD80", Offset = "0x2F1BB80", VA = "0x182F1CD80")]
			internal bool AddByte(byte b1)
			{
				return default(bool);
			}

			// Token: 0x060011F1 RID: 4593 RVA: 0x0000DEF0 File Offset: 0x0000C0F0
			[Token(Token = "0x60011F1")]
			[Address(RVA = "0x2F1CD90", Offset = "0x2F1BB90", VA = "0x182F1CD90")]
			internal bool AddByte(byte b1, byte b2)
			{
				return default(bool);
			}

			// Token: 0x060011F2 RID: 4594 RVA: 0x0000DF08 File Offset: 0x0000C108
			[Token(Token = "0x60011F2")]
			[Address(RVA = "0x2F1CE40", Offset = "0x2F1BC40", VA = "0x182F1CE40")]
			internal bool AddByte(byte b1, byte b2, int moreBytesExpected)
			{
				return default(bool);
			}

			// Token: 0x060011F3 RID: 4595 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60011F3")]
			[Address(RVA = "0x2F1D020", Offset = "0x2F1BE20", VA = "0x182F1D020")]
			internal void MovePrevious(bool bThrow)
			{
			}

			// Token: 0x170001CF RID: 463
			// (get) Token: 0x060011F4 RID: 4596 RVA: 0x0000DF20 File Offset: 0x0000C120
			[Token(Token = "0x170001CF")]
			internal bool MoreData
			{
				[Token(Token = "0x60011F4")]
				[Address(RVA = "0x2F1D360", Offset = "0x2F1C160", VA = "0x182F1D360")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x060011F5 RID: 4597 RVA: 0x0000DF38 File Offset: 0x0000C138
			[Token(Token = "0x60011F5")]
			[Address(RVA = "0x2F1CFB0", Offset = "0x2F1BDB0", VA = "0x182F1CFB0")]
			internal char GetNextChar()
			{
				return '\0';
			}

			// Token: 0x170001D0 RID: 464
			// (get) Token: 0x060011F6 RID: 4598 RVA: 0x0000DF50 File Offset: 0x0000C150
			[Token(Token = "0x170001D0")]
			internal int CharsUsed
			{
				[Token(Token = "0x60011F6")]
				[Address(RVA = "0x2F1D340", Offset = "0x2F1C140", VA = "0x182F1D340")]
				get
				{
					return 0;
				}
			}

			// Token: 0x170001D1 RID: 465
			// (get) Token: 0x060011F7 RID: 4599 RVA: 0x0000DF68 File Offset: 0x0000C168
			[Token(Token = "0x170001D1")]
			internal int Count
			{
				[Token(Token = "0x60011F7")]
				[Address(RVA = "0x3F63F0", Offset = "0x3F51F0", VA = "0x1803F63F0")]
				get
				{
					return 0;
				}
			}

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

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

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

			// Token: 0x04000962 RID: 2402
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000962")]
			private unsafe char* chars;

			// Token: 0x04000963 RID: 2403
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000963")]
			private unsafe char* charStart;

			// Token: 0x04000964 RID: 2404
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x4000964")]
			private unsafe char* charEnd;

			// Token: 0x04000965 RID: 2405
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
			[Token(Token = "0x4000965")]
			private int byteCountResult;

			// Token: 0x04000966 RID: 2406
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
			[Token(Token = "0x4000966")]
			private Encoding enc;

			// Token: 0x04000967 RID: 2407
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
			[Token(Token = "0x4000967")]
			private EncoderNLS encoder;

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