using System;
using Cpp2IlInjected;

namespace System.Text
{
	/// <summary>Represents a UTF-32 encoding of Unicode characters.</summary>
	// Token: 0x020001DF RID: 479
	[Token(Token = "0x20001DF")]
	[Serializable]
	public sealed class UTF32Encoding : Encoding
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF32Encoding" /> class.</summary>
		// Token: 0x0600127A RID: 4730 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600127A")]
		[Address(RVA = "0x2F2D440", Offset = "0x2F2C240", VA = "0x182F2D440")]
		public UTF32Encoding()
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF32Encoding" /> class. Parameters specify whether to use the big endian byte order and whether the <see cref="M:System.Text.UTF32Encoding.GetPreamble" /> method returns a Unicode 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 a Unicode byte order mark is provided; otherwise, <see langword="false" />.</param>
		// Token: 0x0600127B RID: 4731 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600127B")]
		[Address(RVA = "0x2F2D360", Offset = "0x2F2C160", VA = "0x182F2D360")]
		public UTF32Encoding(bool bigEndian, bool byteOrderMark)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF32Encoding" /> 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), 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 a Unicode byte order mark is provided; otherwise, <see langword="false" />.</param>
		/// <param name="throwOnInvalidCharacters">
		///   <see langword="true" /> to specify that an exception should be thrown when an invalid encoding is detected; otherwise, <see langword="false" />.</param>
		// Token: 0x0600127C RID: 4732 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600127C")]
		[Address(RVA = "0x2F2D3C0", Offset = "0x2F2C1C0", VA = "0x182F2D3C0")]
		public UTF32Encoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidCharacters)
		{
		}

		// Token: 0x0600127D RID: 4733 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600127D")]
		[Address(RVA = "0x2F2D2C0", Offset = "0x2F2C0C0", VA = "0x182F2D2C0", 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-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600127E RID: 4734 RVA: 0x0000E358 File Offset: 0x0000C558
		[Token(Token = "0x600127E")]
		[Address(RVA = "0x2F2A9A0", Offset = "0x2F297A0", VA = "0x182F2A9A0", 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="s">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="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 complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x0600127F RID: 4735 RVA: 0x0000E370 File Offset: 0x0000C570
		[Token(Token = "0x600127F")]
		[Address(RVA = "0x2F2B000", Offset = "0x2F29E00", VA = "0x182F2B000", 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 complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.EncoderFallback" /> is set to <see cref="T:System.Text.EncoderExceptionFallback" />.</exception>
		// Token: 0x06001280 RID: 4736 RVA: 0x0000E388 File Offset: 0x0000C588
		[Token(Token = "0x6001280")]
		[Address(RVA = "0x2F2AB30", Offset = "0x2F29930", VA = "0x182F2AB30", Slot = "14")]
		[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: 0x06001281 RID: 4737 RVA: 0x0000E3A0 File Offset: 0x0000C5A0
		[Token(Token = "0x6001281")]
		[Address(RVA = "0x2F2B9C0", Offset = "0x2F2A7C0", VA = "0x182F2B9C0", 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: 0x06001282 RID: 4738 RVA: 0x0000E3B8 File Offset: 0x0000C5B8
		[Token(Token = "0x6001282")]
		[Address(RVA = "0x2F2B760", Offset = "0x2F2A560", VA = "0x182F2B760", 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" />.  
		/// -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: 0x06001283 RID: 4739 RVA: 0x0000E3D0 File Offset: 0x0000C5D0
		[Token(Token = "0x6001283")]
		[Address(RVA = "0x2F2B0A0", Offset = "0x2F29EA0", VA = "0x182F2B0A0", Slot = "22")]
		[CLSCompliant(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: 0x06001284 RID: 4740 RVA: 0x0000E3E8 File Offset: 0x0000C5E8
		[Token(Token = "0x6001284")]
		[Address(RVA = "0x2F2BD20", Offset = "0x2F2AB20", VA = "0x182F2BD20", 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: 0x06001285 RID: 4741 RVA: 0x0000E400 File Offset: 0x0000C600
		[Token(Token = "0x6001285")]
		[Address(RVA = "0x2F2BC20", Offset = "0x2F2AA20", VA = "0x182F2BC20", Slot = "24")]
		[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: 0x06001286 RID: 4742 RVA: 0x0000E418 File Offset: 0x0000C618
		[Token(Token = "0x6001286")]
		[Address(RVA = "0x2F2C870", Offset = "0x2F2B670", VA = "0x182F2C870", 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: 0x06001287 RID: 4743 RVA: 0x0000E430 File Offset: 0x0000C630
		[Token(Token = "0x6001287")]
		[Address(RVA = "0x2F2CAD0", Offset = "0x2F2B8D0", VA = "0x182F2CAD0", Slot = "29")]
		[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 string that contains 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 a complete explanation)  
		///  -and-  
		///  <see cref="P:System.Text.Encoding.DecoderFallback" /> is set to <see cref="T:System.Text.DecoderExceptionFallback" />.</exception>
		// Token: 0x06001288 RID: 4744 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001288")]
		[Address(RVA = "0x2F2D110", Offset = "0x2F2BF10", VA = "0x182F2D110", Slot = "37")]
		public override string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		// Token: 0x06001289 RID: 4745 RVA: 0x0000E448 File Offset: 0x0000C648
		[Token(Token = "0x6001289")]
		[Address(RVA = "0x2F2AC30", Offset = "0x2F29A30", VA = "0x182F2AC30", Slot = "15")]
		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x0600128A RID: 4746 RVA: 0x0000E460 File Offset: 0x0000C660
		[Token(Token = "0x600128A")]
		[Address(RVA = "0x2F2B1E0", Offset = "0x2F29FE0", VA = "0x182F2B1E0", Slot = "21")]
		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x0600128B RID: 4747 RVA: 0x0000E478 File Offset: 0x0000C678
		[Token(Token = "0x600128B")]
		[Address(RVA = "0x2F2BEB0", Offset = "0x2F2ACB0", VA = "0x182F2BEB0", Slot = "25")]
		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x0600128C RID: 4748 RVA: 0x0000E490 File Offset: 0x0000C690
		[Token(Token = "0x600128C")]
		[Address(RVA = "0x2F2C290", Offset = "0x2F2B090", VA = "0x182F2C290", Slot = "30")]
		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x0600128D RID: 4749 RVA: 0x0000E4A8 File Offset: 0x0000C6A8
		[Token(Token = "0x600128D")]
		[Address(RVA = "0x2F2D2A0", Offset = "0x2F2C0A0", VA = "0x182F2D2A0")]
		private uint GetSurrogate(char cHigh, char cLow)
		{
			return 0U;
		}

		// Token: 0x0600128E RID: 4750 RVA: 0x0000E4C0 File Offset: 0x0000C6C0
		[Token(Token = "0x600128E")]
		[Address(RVA = "0x2F2CDB0", Offset = "0x2F2BBB0", VA = "0x182F2CDB0")]
		private char GetHighSurrogate(uint iChar)
		{
			return '\0';
		}

		// Token: 0x0600128F RID: 4751 RVA: 0x0000E4D8 File Offset: 0x0000C6D8
		[Token(Token = "0x600128F")]
		[Address(RVA = "0x2F2CDD0", Offset = "0x2F2BBD0", VA = "0x182F2CDD0")]
		private char GetLowSurrogate(uint iChar)
		{
			return '\0';
		}

		/// <summary>Obtains a decoder that converts a UTF-32 encoded sequence of bytes into a sequence of Unicode characters.</summary>
		/// <returns>A <see cref="T:System.Text.Decoder" /> that converts a UTF-32 encoded sequence of bytes into a sequence of Unicode characters.</returns>
		// Token: 0x06001290 RID: 4752 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001290")]
		[Address(RVA = "0x2F2CC10", Offset = "0x2F2BA10", VA = "0x182F2CC10", Slot = "32")]
		public override Decoder GetDecoder()
		{
			return null;
		}

		/// <summary>Obtains an encoder that converts a sequence of Unicode characters into a UTF-32 encoded sequence of bytes.</summary>
		/// <returns>A <see cref="T:System.Text.Encoder" /> that converts a sequence of Unicode characters into a UTF-32 encoded sequence of bytes.</returns>
		// Token: 0x06001291 RID: 4753 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001291")]
		[Address(RVA = "0x2F2CC90", Offset = "0x2F2BA90", VA = "0x182F2CC90", 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: 0x06001292 RID: 4754 RVA: 0x0000E4F0 File Offset: 0x0000C6F0
		[Token(Token = "0x6001292")]
		[Address(RVA = "0x2F2CDF0", Offset = "0x2F2BBF0", VA = "0x182F2CDF0", 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: 0x06001293 RID: 4755 RVA: 0x0000E508 File Offset: 0x0000C708
		[Token(Token = "0x6001293")]
		[Address(RVA = "0x2F2CF20", Offset = "0x2F2BD20", VA = "0x182F2CF20", Slot = "35")]
		public override int GetMaxCharCount(int byteCount)
		{
			return 0;
		}

		/// <summary>Returns a Unicode byte order mark encoded in UTF-32 format, if the <see cref="T:System.Text.UTF32Encoding" /> object is configured to supply one.</summary>
		/// <returns>A byte array containing the Unicode byte order mark, if the <see cref="T:System.Text.UTF32Encoding" /> object is configured to supply one. Otherwise, this method returns a zero-length byte array.</returns>
		// Token: 0x06001294 RID: 4756 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6001294")]
		[Address(RVA = "0x2F2D000", Offset = "0x2F2BE00", VA = "0x182F2D000", Slot = "6")]
		public override byte[] GetPreamble()
		{
			return null;
		}

		/// <summary>Determines whether the specified <see cref="T:System.Object" /> is equal to the current <see cref="T:System.Text.UTF32Encoding" /> object.</summary>
		/// <param name="value">The <see cref="T:System.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.UTF32Encoding" /> and is equal to the current object; otherwise, <see langword="false" />.</returns>
		// Token: 0x06001295 RID: 4757 RVA: 0x0000E520 File Offset: 0x0000C720
		[Token(Token = "0x6001295")]
		[Address(RVA = "0x2F2A8D0", Offset = "0x2F296D0", VA = "0x182F2A8D0", 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.UTF32Encoding" /> object.</returns>
		// Token: 0x06001296 RID: 4758 RVA: 0x0000E538 File Offset: 0x0000C738
		[Token(Token = "0x6001296")]
		[Address(RVA = "0x2F2CD10", Offset = "0x2F2BB10", VA = "0x182F2CD10", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x0400097E RID: 2430
		[FieldOffset(Offset = "0x38")]
		[Token(Token = "0x400097E")]
		private bool emitUTF32ByteOrderMark;

		// Token: 0x0400097F RID: 2431
		[FieldOffset(Offset = "0x39")]
		[Token(Token = "0x400097F")]
		private bool isThrowException;

		// Token: 0x04000980 RID: 2432
		[FieldOffset(Offset = "0x3A")]
		[Token(Token = "0x4000980")]
		private bool bigEndian;

		// Token: 0x020001E0 RID: 480
		[Token(Token = "0x20001E0")]
		[Serializable]
		internal class UTF32Decoder : DecoderNLS
		{
			// Token: 0x06001297 RID: 4759 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001297")]
			[Address(RVA = "0x2F197D0", Offset = "0x2F185D0", VA = "0x182F197D0")]
			public UTF32Decoder(UTF32Encoding encoding)
			{
			}

			// Token: 0x06001298 RID: 4760 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6001298")]
			[Address(RVA = "0x2F2A890", Offset = "0x2F29690", VA = "0x182F2A890", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001D7 RID: 471
			// (get) Token: 0x06001299 RID: 4761 RVA: 0x0000E550 File Offset: 0x0000C750
			[Token(Token = "0x170001D7")]
			internal override bool HasState
			{
				[Token(Token = "0x6001299")]
				[Address(RVA = "0x2F2A8C0", Offset = "0x2F296C0", VA = "0x182F2A8C0", Slot = "14")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x04000981 RID: 2433
			[FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000981")]
			internal int iChar;

			// Token: 0x04000982 RID: 2434
			[FieldOffset(Offset = "0x34")]
			[Token(Token = "0x4000982")]
			internal int readByteCount;
		}
	}
}