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: 0x020001ED RID: 493
	[Token(Token = "0x20001ED")]
	[ComVisible(true)]
	[Serializable]
	public class UTF8Encoding : Encoding
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF8Encoding" /> class.</summary>
		// Token: 0x06001305 RID: 4869 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001305")]
		[Address(RVA = "0xF38130", Offset = "0xF37130", VA = "0x180F38130")]
		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: 0x06001306 RID: 4870 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001306")]
		[Address(RVA = "0xF38100", Offset = "0xF37100", VA = "0x180F38100")]
		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: 0x06001307 RID: 4871 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001307")]
		[Address(RVA = "0xF380A0", Offset = "0xF370A0", VA = "0x180F380A0")]
		public UTF8Encoding(bool encoderShouldEmitUTF8Identifier, bool throwOnInvalidBytes)
		{
		}

		// Token: 0x06001308 RID: 4872 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001308")]
		[Address(RVA = "0xF38000", Offset = "0xF37000", VA = "0x180F38000", 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: 0x06001309 RID: 4873 RVA: 0x0000EB20 File Offset: 0x0000CD20
		[Token(Token = "0x6001309")]
		[Address(RVA = "0xF35230", Offset = "0xF34230", VA = "0x180F35230", 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: 0x0600130A RID: 4874 RVA: 0x0000EB38 File Offset: 0x0000CD38
		[Token(Token = "0x600130A")]
		[Address(RVA = "0xF353C0", Offset = "0xF343C0", VA = "0x180F353C0", 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: 0x0600130B RID: 4875 RVA: 0x0000EB50 File Offset: 0x0000CD50
		[Token(Token = "0x600130B")]
		[Address(RVA = "0xF34B40", Offset = "0xF33B40", VA = "0x180F34B40", 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: 0x0600130C RID: 4876 RVA: 0x0000EB68 File Offset: 0x0000CD68
		[Token(Token = "0x600130C")]
		[Address(RVA = "0xF361A0", Offset = "0xF351A0", VA = "0x180F361A0", 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: 0x0600130D RID: 4877 RVA: 0x0000EB80 File Offset: 0x0000CD80
		[Token(Token = "0x600130D")]
		[Address(RVA = "0xF35F40", Offset = "0xF34F40", VA = "0x180F35F40", 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: 0x0600130E RID: 4878 RVA: 0x0000EB98 File Offset: 0x0000CD98
		[Token(Token = "0x600130E")]
		[Address(RVA = "0xF36400", Offset = "0xF35400", VA = "0x180F36400", 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: 0x0600130F RID: 4879 RVA: 0x0000EBB0 File Offset: 0x0000CDB0
		[Token(Token = "0x600130F")]
		[Address(RVA = "0xF36B40", Offset = "0xF35B40", VA = "0x180F36B40", 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: 0x06001310 RID: 4880 RVA: 0x0000EBC8 File Offset: 0x0000CDC8
		[Token(Token = "0x6001310")]
		[Address(RVA = "0xF36A40", Offset = "0xF35A40", VA = "0x180F36A40", Slot = "24")]
		[CLSCompliant(false)]
		[ComVisible(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: 0x06001311 RID: 4881 RVA: 0x0000EBE0 File Offset: 0x0000CDE0
		[Token(Token = "0x6001311")]
		[Address(RVA = "0xF36E10", Offset = "0xF35E10", VA = "0x180F36E10", 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: 0x06001312 RID: 4882 RVA: 0x0000EBF8 File Offset: 0x0000CDF8
		[Token(Token = "0x6001312")]
		[Address(RVA = "0xF36CD0", Offset = "0xF35CD0", VA = "0x180F36CD0", Slot = "29")]
		[ComVisible(false)]
		[CLSCompliant(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: 0x06001313 RID: 4883 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001313")]
		[Address(RVA = "0xF37E50", Offset = "0xF36E50", VA = "0x180F37E50", Slot = "37")]
		[ComVisible(false)]
		public override string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		// Token: 0x06001314 RID: 4884 RVA: 0x0000EC10 File Offset: 0x0000CE10
		[Token(Token = "0x6001314")]
		[Address(RVA = "0xF34C40", Offset = "0xF33C40", VA = "0x180F34C40", Slot = "15")]
		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS baseEncoder)
		{
			return 0;
		}

		// Token: 0x06001315 RID: 4885 RVA: 0x0000EC28 File Offset: 0x0000CE28
		[Token(Token = "0x6001315")]
		[Address(RVA = "0xF37FE0", Offset = "0xF36FE0", VA = "0x180F37FE0")]
		private unsafe static int PtrDiff(char* a, char* b)
		{
			return 0;
		}

		// Token: 0x06001316 RID: 4886 RVA: 0x0000EC40 File Offset: 0x0000CE40
		[Token(Token = "0x6001316")]
		[Address(RVA = "0xF37FF0", Offset = "0xF36FF0", VA = "0x180F37FF0")]
		private unsafe static int PtrDiff(byte* a, byte* b)
		{
			return 0;
		}

		// Token: 0x06001317 RID: 4887 RVA: 0x0000EC58 File Offset: 0x0000CE58
		[Token(Token = "0x6001317")]
		[Address(RVA = "0x680D90", Offset = "0x67FD90", VA = "0x180680D90")]
		private static bool InRange(int ch, int start, int end)
		{
			return default(bool);
		}

		// Token: 0x06001318 RID: 4888 RVA: 0x0000EC70 File Offset: 0x0000CE70
		[Token(Token = "0x6001318")]
		[Address(RVA = "0xF35790", Offset = "0xF34790", VA = "0x180F35790", Slot = "21")]
		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS baseEncoder)
		{
			return 0;
		}

		// Token: 0x06001319 RID: 4889 RVA: 0x0000EC88 File Offset: 0x0000CE88
		[Token(Token = "0x6001319")]
		[Address(RVA = "0xF36540", Offset = "0xF35540", VA = "0x180F36540", Slot = "25")]
		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x0600131A RID: 4890 RVA: 0x0000ECA0 File Offset: 0x0000CEA0
		[Token(Token = "0x600131A")]
		[Address(RVA = "0xF37070", Offset = "0xF36070", VA = "0x180F37070", Slot = "30")]
		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x0600131B RID: 4891 RVA: 0x0000ECB8 File Offset: 0x0000CEB8
		[Token(Token = "0x600131B")]
		[Address(RVA = "0xF34A70", Offset = "0xF33A70", VA = "0x180F34A70")]
		private unsafe bool FallbackInvalidByteSequence(ref byte* pSrc, int ch, DecoderFallbackBuffer fallback, ref char* pTarget)
		{
			return default(bool);
		}

		// Token: 0x0600131C RID: 4892 RVA: 0x0000ECD0 File Offset: 0x0000CED0
		[Token(Token = "0x600131C")]
		[Address(RVA = "0xF34AF0", Offset = "0xF33AF0", VA = "0x180F34AF0")]
		private unsafe int FallbackInvalidByteSequence(byte* pSrc, int ch, DecoderFallbackBuffer fallback)
		{
			return 0;
		}

		// Token: 0x0600131D RID: 4893 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600131D")]
		[Address(RVA = "0xF35460", Offset = "0xF34460", VA = "0x180F35460")]
		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: 0x0600131E RID: 4894 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600131E")]
		[Address(RVA = "0xF37A40", Offset = "0xF36A40", VA = "0x180F37A40", 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: 0x0600131F RID: 4895 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600131F")]
		[Address(RVA = "0xF37AA0", Offset = "0xF36AA0", VA = "0x180F37AA0", 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: 0x06001320 RID: 4896 RVA: 0x0000ECE8 File Offset: 0x0000CEE8
		[Token(Token = "0x6001320")]
		[Address(RVA = "0xF37B70", Offset = "0xF36B70", VA = "0x180F37B70", 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: 0x06001321 RID: 4897 RVA: 0x0000ED00 File Offset: 0x0000CF00
		[Token(Token = "0x6001321")]
		[Address(RVA = "0xF37C90", Offset = "0xF36C90", VA = "0x180F37C90", 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: 0x06001322 RID: 4898 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001322")]
		[Address(RVA = "0xF37DB0", Offset = "0xF36DB0", VA = "0x180F37DB0", 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: 0x06001323 RID: 4899 RVA: 0x0000ED18 File Offset: 0x0000CF18
		[Token(Token = "0x6001323")]
		[Address(RVA = "0xF34980", Offset = "0xF33980", VA = "0x180F34980", 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: 0x06001324 RID: 4900 RVA: 0x0000ED30 File Offset: 0x0000CF30
		[Token(Token = "0x6001324")]
		[Address(RVA = "0xF37B00", Offset = "0xF36B00", VA = "0x180F37B00", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x04000999 RID: 2457
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
		[Token(Token = "0x4000999")]
		private bool emitUTF8Identifier;

		// Token: 0x0400099A RID: 2458
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x39")]
		[Token(Token = "0x400099A")]
		private bool isThrowException;

		// Token: 0x020001EE RID: 494
		[Token(Token = "0x20001EE")]
		[Serializable]
		internal class UTF8Encoder : EncoderNLS, ISerializable
		{
			// Token: 0x06001325 RID: 4901 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001325")]
			[Address(RVA = "0xF2B0F0", Offset = "0xF2A0F0", VA = "0x180F2B0F0")]
			public UTF8Encoder(UTF8Encoding encoding)
			{
			}

			// Token: 0x06001326 RID: 4902 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001326")]
			[Address(RVA = "0xF34720", Offset = "0xF33720", VA = "0x180F34720")]
			internal UTF8Encoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x06001327 RID: 4903 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001327")]
			[Address(RVA = "0xF34640", Offset = "0xF33640", VA = "0x180F34640", Slot = "11")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x06001328 RID: 4904 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001328")]
			[Address(RVA = "0xF34610", Offset = "0xF33610", VA = "0x180F34610", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001E4 RID: 484
			// (get) Token: 0x06001329 RID: 4905 RVA: 0x0000ED48 File Offset: 0x0000CF48
			[Token(Token = "0x170001E4")]
			internal override bool HasState
			{
				[Token(Token = "0x6001329")]
				[Address(RVA = "0xF34970", Offset = "0xF33970", VA = "0x180F34970", Slot = "12")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x0400099B RID: 2459
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
			[Token(Token = "0x400099B")]
			internal int surrogateChar;
		}

		// Token: 0x020001EF RID: 495
		[Token(Token = "0x20001EF")]
		[Serializable]
		internal class UTF8Decoder : DecoderNLS, ISerializable
		{
			// Token: 0x0600132A RID: 4906 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600132A")]
			[Address(RVA = "0xF2ADF0", Offset = "0xF29DF0", VA = "0x180F2ADF0")]
			public UTF8Decoder(UTF8Encoding encoding)
			{
			}

			// Token: 0x0600132B RID: 4907 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600132B")]
			[Address(RVA = "0xF343C0", Offset = "0xF333C0", VA = "0x180F343C0")]
			internal UTF8Decoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x0600132C RID: 4908 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600132C")]
			[Address(RVA = "0xF342B0", Offset = "0xF332B0", VA = "0x180F342B0", Slot = "13")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x0600132D RID: 4909 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x600132D")]
			[Address(RVA = "0xF34280", Offset = "0xF33280", VA = "0x180F34280", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001E5 RID: 485
			// (get) Token: 0x0600132E RID: 4910 RVA: 0x0000ED60 File Offset: 0x0000CF60
			[Token(Token = "0x170001E5")]
			internal override bool HasState
			{
				[Token(Token = "0x600132E")]
				[Address(RVA = "0x6CB260", Offset = "0x6CA260", VA = "0x1806CB260", Slot = "14")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x0400099C RID: 2460
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x400099C")]
			internal int bits;
		}
	}
}