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

namespace System.Text
{
	/// <summary>Represents a UTF-8 encoding of Unicode characters.</summary>
	// Token: 0x020001E6 RID: 486
	[Token(Token = "0x20001E6")]
	[ComVisible(true)]
	[Serializable]
	public class UTF8Encoding : Encoding
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class.</summary>
		// Token: 0x060012C9 RID: 4809 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012C9")]
		[Address(RVA = "0x292C850", Offset = "0x292B650", VA = "0x18292C850")]
		public UTF8Encoding()
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class. A parameter specifies whether to provide a Unicode byte order mark.</summary>
		/// <param name="encoderShouldEmitUTF8Identifier">
		///   <see langword="true" /> to specify that the <see cref="M:System.Text.UTF8Encoding.GetPreamble" /> method returns a Unicode byte order mark; otherwise, <see langword="false" />.</param>
		// Token: 0x060012CA RID: 4810 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012CA")]
		[Address(RVA = "0x292C820", Offset = "0x292B620", VA = "0x18292C820")]
		public UTF8Encoding(bool encoderShouldEmitUTF8Identifier)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class. Parameters specify whether to provide a Unicode byte order mark and whether to throw an exception when an invalid encoding is detected.</summary>
		/// <param name="encoderShouldEmitUTF8Identifier">
		///   <see langword="true" /> to specify that the <see cref="M:System.Text.UTF8Encoding.GetPreamble" /> method should return a Unicode byte order mark; otherwise, <see langword="false" />.</param>
		/// <param name="throwOnInvalidBytes">
		///   <see langword="true" /> to throw an exception when an invalid encoding is detected; otherwise, <see langword="false" />.</param>
		// Token: 0x060012CB RID: 4811 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012CB")]
		[Address(RVA = "0x292C7C0", Offset = "0x292B5C0", VA = "0x18292C7C0")]
		public UTF8Encoding(bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes)
		{
		}

		// Token: 0x060012CC RID: 4812 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012CC")]
		[Address(RVA = "0x292C720", Offset = "0x292B520", VA = "0x18292C720", Slot = "5")]
		internal override void SetDefaultFallbacks()
		{
		}

		/// <summary>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" />.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  The <see cref="P:System.Text.Encoding.EncoderFallback" /> property is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012CD RID: 4813 RVA: 0x0000E7D8 File Offset: 0x0000C9D8
		[Token(Token = "0x60012CD")]
		[Address(RVA = "0x2929950", Offset = "0x2928750", VA = "0x182929950", Slot = "13")]
		public override int GetByteCount(char[] chars, int index, int count)
		{
			return 0;
		}

		/// <summary>Calculates the number of bytes produced by encoding the characters in the specified <see cref="T:System.String" />.</summary>
		/// <param name="chars">The <see cref="T:System.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="chars" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012CE RID: 4814 RVA: 0x0000E7F0 File Offset: 0x0000C9F0
		[Token(Token = "0x60012CE")]
		[Address(RVA = "0x2929AE0", Offset = "0x29288E0", VA = "0x182929AE0", Slot = "12")]
		public override int GetByteCount(string chars)
		{
			return 0;
		}

		/// <summary>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.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for a complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012CF RID: 4815 RVA: 0x0000E808 File Offset: 0x0000CA08
		[Token(Token = "0x60012CF")]
		[Address(RVA = "0x2929260", Offset = "0x2928060", VA = "0x182929260", Slot = "14")]
		[ComVisible(false)]
		[CLSCompliant(false)]
		public unsafe override int GetByteCount(char* chars, int count)
		{
			return 0;
		}

		/// <summary>Encodes a set of characters from the specified <see cref="T:System.String" /> into the specified byte array.</summary>
		/// <param name="s">The <see cref="T:System.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">Error detection is enabled, and <paramref name="s" /> contains an invalid sequence of characters.  
		///  -or-  
		///  <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 the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012D0 RID: 4816 RVA: 0x0000E820 File Offset: 0x0000CA20
		[Token(Token = "0x60012D0")]
		[Address(RVA = "0x292A8C0", Offset = "0x29296C0", VA = "0x18292A8C0", Slot = "20")]
		public override int GetBytes(string s, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			return 0;
		}

		/// <summary>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">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.  
		///  -or-  
		///  <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 the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012D1 RID: 4817 RVA: 0x0000E838 File Offset: 0x0000CA38
		[Token(Token = "0x60012D1")]
		[Address(RVA = "0x292A660", Offset = "0x2929460", VA = "0x18292A660", Slot = "18")]
		public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
		{
			return 0;
		}

		/// <summary>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 <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="charCount" /> or <paramref name="byteCount" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="chars" /> contains an invalid sequence of characters.  
		///  -or-  
		///  <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 the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012D2 RID: 4818 RVA: 0x0000E850 File Offset: 0x0000CA50
		[Token(Token = "0x60012D2")]
		[Address(RVA = "0x292AB20", Offset = "0x2929920", VA = "0x18292AB20", Slot = "22")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount)
		{
			return 0;
		}

		/// <summary>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" />.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012D3 RID: 4819 RVA: 0x0000E868 File Offset: 0x0000CA68
		[Token(Token = "0x60012D3")]
		[Address(RVA = "0x292B260", Offset = "0x292A060", VA = "0x18292B260", Slot = "23")]
		public override int GetCharCount(byte[] bytes, int index, int count)
		{
			return 0;
		}

		/// <summary>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.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012D4 RID: 4820 RVA: 0x0000E880 File Offset: 0x0000CA80
		[Token(Token = "0x60012D4")]
		[Address(RVA = "0x292B160", Offset = "0x2929F60", VA = "0x18292B160", Slot = "24")]
		[ComVisible(false)]
		[CLSCompliant(false)]
		public unsafe override int GetCharCount(byte* bytes, int count)
		{
			return 0;
		}

		/// <summary>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">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.  
		///  -or-  
		///  <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 the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012D5 RID: 4821 RVA: 0x0000E898 File Offset: 0x0000CA98
		[Token(Token = "0x60012D5")]
		[Address(RVA = "0x292B530", Offset = "0x292A330", VA = "0x18292B530", Slot = "28")]
		public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
		{
			return 0;
		}

		/// <summary>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 <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="byteCount" /> or <paramref name="charCount" /> is less than zero.</exception>
		/// <exception cref="T:System.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.  
		///  -or-  
		///  <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 the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012D6 RID: 4822 RVA: 0x0000E8B0 File Offset: 0x0000CAB0
		[Token(Token = "0x60012D6")]
		[Address(RVA = "0x292B3F0", Offset = "0x292A1F0", VA = "0x18292B3F0", Slot = "29")]
		[CLSCompliant(false)]
		[ComVisible(false)]
		public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
		{
			return 0;
		}

		/// <summary>Decodes a range of bytes from a 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 <see cref="T:System.String" /> 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.ArgumentException">Error detection is enabled, and <paramref name="bytes" /> contains an invalid sequence of bytes.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012D7 RID: 4823 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012D7")]
		[Address(RVA = "0x292C570", Offset = "0x292B370", VA = "0x18292C570", Slot = "37")]
		[ComVisible(false)]
		public override string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		// Token: 0x060012D8 RID: 4824 RVA: 0x0000E8C8 File Offset: 0x0000CAC8
		[Token(Token = "0x60012D8")]
		[Address(RVA = "0x2929360", Offset = "0x2928160", VA = "0x182929360", Slot = "15")]
		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS baseEncoder)
		{
			return 0;
		}

		// Token: 0x060012D9 RID: 4825 RVA: 0x0000E8E0 File Offset: 0x0000CAE0
		[Token(Token = "0x60012D9")]
		[Address(RVA = "0x292C700", Offset = "0x292B500", VA = "0x18292C700")]
		private unsafe static int PtrDiff(char* a, char* b)
		{
			return 0;
		}

		// Token: 0x060012DA RID: 4826 RVA: 0x0000E8F8 File Offset: 0x0000CAF8
		[Token(Token = "0x60012DA")]
		[Address(RVA = "0x292C710", Offset = "0x292B510", VA = "0x18292C710")]
		private unsafe static int PtrDiff(byte* a, byte* b)
		{
			return 0;
		}

		// Token: 0x060012DB RID: 4827 RVA: 0x0000E910 File Offset: 0x0000CB10
		[Token(Token = "0x60012DB")]
		[Address(RVA = "0x461290", Offset = "0x460090", VA = "0x180461290")]
		private static bool InRange(int ch, int start, int end)
		{
			return default(bool);
		}

		// Token: 0x060012DC RID: 4828 RVA: 0x0000E928 File Offset: 0x0000CB28
		[Token(Token = "0x60012DC")]
		[Address(RVA = "0x2929EB0", Offset = "0x2928CB0", VA = "0x182929EB0", Slot = "21")]
		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS baseEncoder)
		{
			return 0;
		}

		// Token: 0x060012DD RID: 4829 RVA: 0x0000E940 File Offset: 0x0000CB40
		[Token(Token = "0x60012DD")]
		[Address(RVA = "0x292AC60", Offset = "0x2929A60", VA = "0x18292AC60", Slot = "25")]
		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x060012DE RID: 4830 RVA: 0x0000E958 File Offset: 0x0000CB58
		[Token(Token = "0x60012DE")]
		[Address(RVA = "0x292B790", Offset = "0x292A590", VA = "0x18292B790", Slot = "30")]
		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x060012DF RID: 4831 RVA: 0x0000E970 File Offset: 0x0000CB70
		[Token(Token = "0x60012DF")]
		[Address(RVA = "0x2929190", Offset = "0x2927F90", VA = "0x182929190")]
		private unsafe bool FallbackInvalidByteSequence(ref byte* pSrc, int ch, DecoderFallbackBuffer fallback, ref char* pTarget)
		{
			return default(bool);
		}

		// Token: 0x060012E0 RID: 4832 RVA: 0x0000E988 File Offset: 0x0000CB88
		[Token(Token = "0x60012E0")]
		[Address(RVA = "0x2929210", Offset = "0x2928010", VA = "0x182929210")]
		private unsafe int FallbackInvalidByteSequence(byte* pSrc, int ch, DecoderFallbackBuffer fallback)
		{
			return 0;
		}

		// Token: 0x060012E1 RID: 4833 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012E1")]
		[Address(RVA = "0x2929B80", Offset = "0x2928980", VA = "0x182929B80")]
		private unsafe byte[] GetBytesUnknown(ref byte* pSrc, int ch)
		{
			return null;
		}

		/// <summary>Obtains a decoder that converts a UTF-8 encoded sequence of bytes into a sequence of Unicode characters.</summary>
		/// <returns>A decoder that converts a UTF-8 encoded sequence of bytes into a sequence of Unicode characters.</returns>
		// Token: 0x060012E2 RID: 4834 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012E2")]
		[Address(RVA = "0x292C160", Offset = "0x292AF60", VA = "0x18292C160", Slot = "32")]
		public override Decoder GetDecoder()
		{
			return null;
		}

		/// <summary>Obtains an encoder that converts a sequence of Unicode characters into a UTF-8 encoded sequence of bytes.</summary>
		/// <returns>A <see cref="T:System.Text.Encoder" /> that converts a sequence of Unicode characters into a UTF-8 encoded sequence of bytes.</returns>
		// Token: 0x060012E3 RID: 4835 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012E3")]
		[Address(RVA = "0x292C1C0", Offset = "0x292AFC0", VA = "0x18292C1C0", Slot = "33")]
		public override Encoder GetEncoder()
		{
			return null;
		}

		/// <summary>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.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012E4 RID: 4836 RVA: 0x0000E9A0 File Offset: 0x0000CBA0
		[Token(Token = "0x60012E4")]
		[Address(RVA = "0x292C290", Offset = "0x292B090", VA = "0x18292C290", Slot = "34")]
		public override int GetMaxByteCount(int charCount)
		{
			return 0;
		}

		/// <summary>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.  
		/// -or-  
		/// The resulting number of bytes is greater than the maximum number that can be returned as an integer.</exception>
		/// <exception cref="T:System.Text.DecoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012E5 RID: 4837 RVA: 0x0000E9B8 File Offset: 0x0000CBB8
		[Token(Token = "0x60012E5")]
		[Address(RVA = "0x292C3B0", Offset = "0x292B1B0", VA = "0x18292C3B0", Slot = "35")]
		public override int GetMaxCharCount(int byteCount)
		{
			return 0;
		}

		/// <summary>Returns a Unicode byte order mark encoded in UTF-8 format, if the <see cref="T:System.Text.UTF8Encoding" /> encoding object is configured to supply one.</summary>
		/// <returns>A byte array containing the Unicode byte order mark, if the <see cref="T:System.Text.UTF8Encoding" /> encoding object is configured to supply one. Otherwise, this method returns a zero-length byte array.</returns>
		// Token: 0x060012E6 RID: 4838 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012E6")]
		[Address(RVA = "0x292C4D0", Offset = "0x292B2D0", VA = "0x18292C4D0", Slot = "6")]
		public override byte[] GetPreamble()
		{
			return null;
		}

		/// <summary>Determines whether the specified object is equal to the current <see cref="T:System.Text.UTF8Encoding" /> object.</summary>
		/// <param name="value">The 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.UTF8Encoding" /> and is equal to the current object; otherwise, <see langword="false" />.</returns>
		// Token: 0x060012E7 RID: 4839 RVA: 0x0000E9D0 File Offset: 0x0000CBD0
		[Token(Token = "0x60012E7")]
		[Address(RVA = "0x29290A0", Offset = "0x2927EA0", VA = "0x1829290A0", 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: 0x060012E8 RID: 4840 RVA: 0x0000E9E8 File Offset: 0x0000CBE8
		[Token(Token = "0x60012E8")]
		[Address(RVA = "0x292C220", Offset = "0x292B020", VA = "0x18292C220", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x0400098F RID: 2447
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
		[Token(Token = "0x400098F")]
		private bool emitUTF8Identifier;

		// Token: 0x04000990 RID: 2448
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x39")]
		[Token(Token = "0x4000990")]
		private bool isThrowException;

		// Token: 0x020001E7 RID: 487
		[Token(Token = "0x20001E7")]
		[Serializable]
		internal class UTF8Encoder : EncoderNLS, ISerializable
		{
			// Token: 0x060012E9 RID: 4841 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012E9")]
			[Address(RVA = "0x2920260", Offset = "0x291F060", VA = "0x182920260")]
			public UTF8Encoder(UTF8Encoding encoding)
			{
			}

			// Token: 0x060012EA RID: 4842 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012EA")]
			[Address(RVA = "0x2928E50", Offset = "0x2927C50", VA = "0x182928E50")]
			internal UTF8Encoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012EB RID: 4843 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012EB")]
			[Address(RVA = "0x2928D70", Offset = "0x2927B70", VA = "0x182928D70", Slot = "9")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012EC RID: 4844 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012EC")]
			[Address(RVA = "0x2928D40", Offset = "0x2927B40", VA = "0x182928D40", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x04000991 RID: 2449
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x4000991")]
			internal int surrogateChar;
		}

		// Token: 0x020001E8 RID: 488
		[Token(Token = "0x20001E8")]
		[Serializable]
		internal class UTF8Decoder : DecoderNLS, ISerializable
		{
			// Token: 0x060012ED RID: 4845 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012ED")]
			[Address(RVA = "0x2928AD0", Offset = "0x29278D0", VA = "0x182928AD0")]
			public UTF8Decoder(UTF8Encoding encoding)
			{
			}

			// Token: 0x060012EE RID: 4846 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012EE")]
			[Address(RVA = "0x2928AE0", Offset = "0x29278E0", VA = "0x182928AE0")]
			internal UTF8Decoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012EF RID: 4847 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012EF")]
			[Address(RVA = "0x29289C0", Offset = "0x29277C0", VA = "0x1829289C0", Slot = "13")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012F0 RID: 4848 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012F0")]
			[Address(RVA = "0x2928990", Offset = "0x2927790", VA = "0x182928990", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001DB RID: 475
			// (get) Token: 0x060012F1 RID: 4849 RVA: 0x0000EA00 File Offset: 0x0000CC00
			[Token(Token = "0x170001DB")]
			internal override bool HasState
			{
				[Token(Token = "0x60012F1")]
				[Address(RVA = "0x2928D30", Offset = "0x2927B30", VA = "0x182928D30", Slot = "14")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x04000992 RID: 2450
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000992")]
			internal int bits;
		}
	}
}