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

namespace System.Text
{
	/// <summary>Represents a UTF-16 encoding of Unicode characters.</summary>
	// Token: 0x020001E4 RID: 484
	[Token(Token = "0x20001E4")]
	[ComVisible(true)]
	[Serializable]
	public class UnicodeEncoding : Encoding
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UnicodeEncoding" /> class.</summary>
		// Token: 0x06001294 RID: 4756 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001294")]
		[Address(RVA = "0xF3C020", Offset = "0xF3B020", VA = "0x180F3C020")]
		public UnicodeEncoding()
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UnicodeEncoding" /> class. Parameters specify whether to use the big endian byte order and whether the <see cref="M:System.Text.UnicodeEncoding.GetPreamble" /> method returns a Unicode byte order mark.</summary>
		/// <param name="bigEndian">
		///   <see langword="true" /> to use the big endian byte order (most significant byte first), or <see langword="false" /> to use the little endian byte order (least significant byte first).</param>
		/// <param name="byteOrderMark">
		///   <see langword="true" /> to specify that the <see cref="M:System.Text.UnicodeEncoding.GetPreamble" /> method returns a Unicode byte order mark; otherwise, <see langword="false" />.</param>
		// Token: 0x06001295 RID: 4757 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001295")]
		[Address(RVA = "0xF3BF60", Offset = "0xF3AF60", VA = "0x180F3BF60")]
		public UnicodeEncoding(bool bigEndian, bool byteOrderMark)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UnicodeEncoding" /> class. Parameters specify whether to use the big endian byte order, whether to provide a Unicode byte order mark, and whether to throw an exception when an invalid encoding is detected.</summary>
		/// <param name="bigEndian">
		///   <see langword="true" /> to use the big endian byte order (most significant byte first); <see langword="false" /> to use the little endian byte order (least significant byte first).</param>
		/// <param name="byteOrderMark">
		///   <see langword="true" /> to specify that the <see cref="M:System.Text.UnicodeEncoding.GetPreamble" /> method returns a Unicode byte order mark; otherwise, <see langword="false" />.</param>
		/// <param name="throwOnInvalidBytes">
		///   <see langword="true" /> to specify that an exception should be thrown when an invalid encoding is detected; otherwise, <see langword="false" />.</param>
		// Token: 0x06001296 RID: 4758 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001296")]
		[Address(RVA = "0xF3BFB0", Offset = "0xF3AFB0", VA = "0x180F3BFB0")]
		public UnicodeEncoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidBytes)
		{
		}

		// Token: 0x06001297 RID: 4759 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001297")]
		[Address(RVA = "0xF3BE30", Offset = "0xF3AE30", VA = "0x180F3BE30")]
		[OnDeserializing]
		private void OnDeserializing(StreamingContext ctx)
		{
		}

		// Token: 0x06001298 RID: 4760 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6001298")]
		[Address(RVA = "0xF3BE40", Offset = "0xF3AE40", VA = "0x180F3BE40", 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" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x06001299 RID: 4761 RVA: 0x0000E4C0 File Offset: 0x0000C6C0
		[Token(Token = "0x6001299")]
		[Address(RVA = "0xF38BD0", Offset = "0xF37BD0", VA = "0x180F38BD0", 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 string.</summary>
		/// <param name="s">The string that contains 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.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="s" /> contains an invalid sequence of characters.</exception>
		/// <exception cref="T:System.Text.EncoderFallbackException">A fallback occurred (see Character Encoding in the .NET Framework for fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600129A RID: 4762 RVA: 0x0000E4D8 File Offset: 0x0000C6D8
		[Token(Token = "0x600129A")]
		[Address(RVA = "0xF38280", Offset = "0xF37280", VA = "0x180F38280", Slot = "12")]
		public override int GetByteCount(string s)
		{
			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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600129B RID: 4763 RVA: 0x0000E4F0 File Offset: 0x0000C6F0
		[Token(Token = "0x600129B")]
		[Address(RVA = "0xF38320", Offset = "0xF37320", VA = "0x180F38320", 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 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" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600129C RID: 4764 RVA: 0x0000E508 File Offset: 0x0000C708
		[Token(Token = "0x600129C")]
		[Address(RVA = "0xF396F0", Offset = "0xF386F0", VA = "0x180F396F0", 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" /> (<see langword="Nothing" />).  
		/// -or-  
		/// <paramref name="bytes" /> is <see langword="null" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600129D RID: 4765 RVA: 0x0000E520 File Offset: 0x0000C720
		[Token(Token = "0x600129D")]
		[Address(RVA = "0xF39A90", Offset = "0xF38A90", VA = "0x180F39A90", 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 the <paramref name="bytes" /> parameter.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="chars" /> is <see langword="null" /> (<see langword="Nothing" />).  
		/// -or-  
		/// <paramref name="bytes" /> is <see langword="null" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600129E RID: 4766 RVA: 0x0000E538 File Offset: 0x0000C738
		[Token(Token = "0x600129E")]
		[Address(RVA = "0xF39950", Offset = "0xF38950", VA = "0x180F39950", 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" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x0600129F RID: 4767 RVA: 0x0000E550 File Offset: 0x0000C750
		[Token(Token = "0x600129F")]
		[Address(RVA = "0xF3A7A0", Offset = "0xF397A0", VA = "0x180F3A7A0", 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" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012A0 RID: 4768 RVA: 0x0000E568 File Offset: 0x0000C768
		[Token(Token = "0x60012A0")]
		[Address(RVA = "0xF39CF0", Offset = "0xF38CF0", VA = "0x180F39CF0", 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" /> (<see langword="Nothing" />).  
		/// -or-  
		/// <paramref name="chars" /> is <see langword="null" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012A1 RID: 4769 RVA: 0x0000E580 File Offset: 0x0000C780
		[Token(Token = "0x60012A1")]
		[Address(RVA = "0xF3A930", Offset = "0xF39930", VA = "0x180F3A930", 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 the <paramref name="chars" /> parameter.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" /> (<see langword="Nothing" />).  
		/// -or-  
		/// <paramref name="chars" /> is <see langword="null" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012A2 RID: 4770 RVA: 0x0000E598 File Offset: 0x0000C798
		[Token(Token = "0x60012A2")]
		[Address(RVA = "0xF3AB90", Offset = "0xF39B90", VA = "0x180F3AB90", 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" /> object containing the results of decoding the specified sequence of bytes.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bytes" /> is <see langword="null" /> (<see langword="Nothing" />).</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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012A3 RID: 4771 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012A3")]
		[Address(RVA = "0xF3BCA0", Offset = "0xF3ACA0", VA = "0x180F3BCA0", Slot = "37")]
		[ComVisible(false)]
		public override string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		// Token: 0x060012A4 RID: 4772 RVA: 0x0000E5B0 File Offset: 0x0000C7B0
		[Token(Token = "0x60012A4")]
		[Address(RVA = "0xF38420", Offset = "0xF37420", VA = "0x180F38420", Slot = "15")]
		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x060012A5 RID: 4773 RVA: 0x0000E5C8 File Offset: 0x0000C7C8
		[Token(Token = "0x60012A5")]
		[Address(RVA = "0xF38D60", Offset = "0xF37D60", VA = "0x180F38D60", Slot = "21")]
		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x060012A6 RID: 4774 RVA: 0x0000E5E0 File Offset: 0x0000C7E0
		[Token(Token = "0x60012A6")]
		[Address(RVA = "0xF39DF0", Offset = "0xF38DF0", VA = "0x180F39DF0", Slot = "25")]
		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x060012A7 RID: 4775 RVA: 0x0000E5F8 File Offset: 0x0000C7F8
		[Token(Token = "0x60012A7")]
		[Address(RVA = "0xF3ACD0", Offset = "0xF39CD0", VA = "0x180F3ACD0", Slot = "30")]
		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			return 0;
		}

		/// <summary>Obtains an encoder that converts a sequence of Unicode characters into a UTF-16 encoded sequence of bytes.</summary>
		/// <returns>A <see cref="T:System.Text.Encoder" /> object that converts a sequence of Unicode characters into a UTF-16 encoded sequence of bytes.</returns>
		// Token: 0x060012A8 RID: 4776 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012A8")]
		[Address(RVA = "0xF3B830", Offset = "0xF3A830", VA = "0x180F3B830", Slot = "33")]
		[ComVisible(false)]
		public override Encoder GetEncoder()
		{
			return null;
		}

		/// <summary>Obtains a decoder that converts a UTF-16 encoded sequence of bytes into a sequence of Unicode characters.</summary>
		/// <returns>A <see cref="T:System.Text.Decoder" /> that converts a UTF-16 encoded sequence of bytes into a sequence of Unicode characters.</returns>
		// Token: 0x060012A9 RID: 4777 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012A9")]
		[Address(RVA = "0xF3B7D0", Offset = "0xF3A7D0", VA = "0x180F3B7D0", Slot = "32")]
		public override global::System.Text.Decoder GetDecoder()
		{
			return null;
		}

		/// <summary>Returns a Unicode byte order mark encoded in UTF-16 format, if the constructor for this instance requests a byte order mark.</summary>
		/// <returns>A byte array containing the Unicode byte order mark, if the <see cref="T:System.Text.UnicodeEncoding" /> object is configured to supply one. Otherwise, this method returns a zero-length byte array.</returns>
		// Token: 0x060012AA RID: 4778 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012AA")]
		[Address(RVA = "0xF3BB90", Offset = "0xF3AB90", VA = "0x180F3BB90", Slot = "6")]
		public override byte[] GetPreamble()
		{
			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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x060012AB RID: 4779 RVA: 0x0000E610 File Offset: 0x0000C810
		[Token(Token = "0x60012AB")]
		[Address(RVA = "0xF3B930", Offset = "0xF3A930", VA = "0x180F3B930", 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 fuller explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x060012AC RID: 4780 RVA: 0x0000E628 File Offset: 0x0000C828
		[Token(Token = "0x60012AC")]
		[Address(RVA = "0xF3BA60", Offset = "0xF3AA60", VA = "0x180F3BA60", Slot = "35")]
		public override int GetMaxCharCount(int byteCount)
		{
			return 0;
		}

		/// <summary>Determines whether the specified <see cref="T:System.Object" /> is equal to the current <see cref="T:System.Text.UnicodeEncoding" /> object.</summary>
		/// <param name="value">The object to compare with the current object.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is an instance of <see cref="T:System.Text.UnicodeEncoding" /> and is equal to the current object; otherwise, <see langword="false" />.</returns>
		// Token: 0x060012AD RID: 4781 RVA: 0x0000E640 File Offset: 0x0000C840
		[Token(Token = "0x60012AD")]
		[Address(RVA = "0xF38160", Offset = "0xF37160", VA = "0x180F38160", 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 <see cref="T:System.Text.UnicodeEncoding" /> object.</returns>
		// Token: 0x060012AE RID: 4782 RVA: 0x0000E658 File Offset: 0x0000C858
		[Token(Token = "0x60012AE")]
		[Address(RVA = "0xF3B890", Offset = "0xF3A890", VA = "0x180F3B890", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x04000982 RID: 2434
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
		[Token(Token = "0x4000982")]
		[OptionalField]
		internal bool isThrowException;

		// Token: 0x04000983 RID: 2435
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x39")]
		[Token(Token = "0x4000983")]
		internal bool bigEndian;

		// Token: 0x04000984 RID: 2436
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x3A")]
		[Token(Token = "0x4000984")]
		internal bool byteOrderMark;

		// Token: 0x04000985 RID: 2437
		[Token(Token = "0x4000985")]
		private static readonly ulong highLowPatternMask;

		// Token: 0x020001E5 RID: 485
		[Token(Token = "0x20001E5")]
		[Serializable]
		private class Decoder : DecoderNLS, ISerializable
		{
			// Token: 0x060012B0 RID: 4784 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012B0")]
			[Address(RVA = "0xF2A860", Offset = "0xF29860", VA = "0x180F2A860")]
			public Decoder(UnicodeEncoding encoding)
			{
			}

			// Token: 0x060012B1 RID: 4785 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012B1")]
			[Address(RVA = "0xF2AAA0", Offset = "0xF29AA0", VA = "0x180F2AAA0")]
			internal Decoder(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012B2 RID: 4786 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012B2")]
			[Address(RVA = "0xF2A610", Offset = "0xF29610", VA = "0x180F2A610", Slot = "13")]
			void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{
			}

			// Token: 0x060012B3 RID: 4787 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012B3")]
			[Address(RVA = "0xF2A5B0", Offset = "0xF295B0", VA = "0x180F2A5B0", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001DE RID: 478
			// (get) Token: 0x060012B4 RID: 4788 RVA: 0x0000E670 File Offset: 0x0000C870
			[Token(Token = "0x170001DE")]
			internal override bool HasState
			{
				[Token(Token = "0x60012B4")]
				[Address(RVA = "0xF2AE10", Offset = "0xF29E10", VA = "0x180F2AE10", Slot = "14")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x04000986 RID: 2438
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000986")]
			internal int lastByte;

			// Token: 0x04000987 RID: 2439
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x34")]
			[Token(Token = "0x4000987")]
			internal char lastChar;
		}
	}
}