using System;
using Cpp2IlInjected;

namespace System.Text
{
	/// <summary>Represents a UTF-32 encoding of Unicode characters.</summary>
	// Token: 0x020001E6 RID: 486
	[Token(Token = "0x20001E6")]
	[Serializable]
	public sealed class UTF32Encoding : Encoding
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Text.UTF32Encoding" /> class.</summary>
		// Token: 0x060012B5 RID: 4789 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012B5")]
		[Address(RVA = "0xF32280", Offset = "0xF31280", VA = "0x180F32280")]
		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: 0x060012B6 RID: 4790 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012B6")]
		[Address(RVA = "0xF321A0", Offset = "0xF311A0", VA = "0x180F321A0")]
		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: 0x060012B7 RID: 4791 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012B7")]
		[Address(RVA = "0xF32200", Offset = "0xF31200", VA = "0x180F32200")]
		public UTF32Encoding(bool bigEndian, bool byteOrderMark, bool throwOnInvalidCharacters)
		{
		}

		// Token: 0x060012B8 RID: 4792 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60012B8")]
		[Address(RVA = "0xF32100", Offset = "0xF31100", VA = "0x180F32100", 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: 0x060012B9 RID: 4793 RVA: 0x0000E688 File Offset: 0x0000C888
		[Token(Token = "0x60012B9")]
		[Address(RVA = "0xF2F9E0", Offset = "0xF2E9E0", VA = "0x180F2F9E0", 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: 0x060012BA RID: 4794 RVA: 0x0000E6A0 File Offset: 0x0000C8A0
		[Token(Token = "0x60012BA")]
		[Address(RVA = "0xF2FFF0", Offset = "0xF2EFF0", VA = "0x180F2FFF0", 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: 0x060012BB RID: 4795 RVA: 0x0000E6B8 File Offset: 0x0000C8B8
		[Token(Token = "0x60012BB")]
		[Address(RVA = "0xF2FB70", Offset = "0xF2EB70", VA = "0x180F2FB70", 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: 0x060012BC RID: 4796 RVA: 0x0000E6D0 File Offset: 0x0000C8D0
		[Token(Token = "0x60012BC")]
		[Address(RVA = "0xF30900", Offset = "0xF2F900", VA = "0x180F30900", 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: 0x060012BD RID: 4797 RVA: 0x0000E6E8 File Offset: 0x0000C8E8
		[Token(Token = "0x60012BD")]
		[Address(RVA = "0xF306A0", Offset = "0xF2F6A0", VA = "0x180F306A0", 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: 0x060012BE RID: 4798 RVA: 0x0000E700 File Offset: 0x0000C900
		[Token(Token = "0x60012BE")]
		[Address(RVA = "0xF30090", Offset = "0xF2F090", VA = "0x180F30090", 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: 0x060012BF RID: 4799 RVA: 0x0000E718 File Offset: 0x0000C918
		[Token(Token = "0x60012BF")]
		[Address(RVA = "0xF30C60", Offset = "0xF2FC60", VA = "0x180F30C60", 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: 0x060012C0 RID: 4800 RVA: 0x0000E730 File Offset: 0x0000C930
		[Token(Token = "0x60012C0")]
		[Address(RVA = "0xF30B60", Offset = "0xF2FB60", VA = "0x180F30B60", 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: 0x060012C1 RID: 4801 RVA: 0x0000E748 File Offset: 0x0000C948
		[Token(Token = "0x60012C1")]
		[Address(RVA = "0xF316F0", Offset = "0xF306F0", VA = "0x180F316F0", 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: 0x060012C2 RID: 4802 RVA: 0x0000E760 File Offset: 0x0000C960
		[Token(Token = "0x60012C2")]
		[Address(RVA = "0xF31950", Offset = "0xF30950", VA = "0x180F31950", 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: 0x060012C3 RID: 4803 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012C3")]
		[Address(RVA = "0xF31F50", Offset = "0xF30F50", VA = "0x180F31F50", Slot = "37")]
		public override string GetString(byte[] bytes, int index, int count)
		{
			return null;
		}

		// Token: 0x060012C4 RID: 4804 RVA: 0x0000E778 File Offset: 0x0000C978
		[Token(Token = "0x60012C4")]
		[Address(RVA = "0xF2FC70", Offset = "0xF2EC70", VA = "0x180F2FC70", Slot = "15")]
		internal unsafe override int GetByteCount(char* chars, int count, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x060012C5 RID: 4805 RVA: 0x0000E790 File Offset: 0x0000C990
		[Token(Token = "0x60012C5")]
		[Address(RVA = "0xF301D0", Offset = "0xF2F1D0", VA = "0x180F301D0", Slot = "21")]
		internal unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, EncoderNLS encoder)
		{
			return 0;
		}

		// Token: 0x060012C6 RID: 4806 RVA: 0x0000E7A8 File Offset: 0x0000C9A8
		[Token(Token = "0x60012C6")]
		[Address(RVA = "0xF30DF0", Offset = "0xF2FDF0", VA = "0x180F30DF0", Slot = "25")]
		internal unsafe override int GetCharCount(byte* bytes, int count, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x060012C7 RID: 4807 RVA: 0x0000E7C0 File Offset: 0x0000C9C0
		[Token(Token = "0x60012C7")]
		[Address(RVA = "0xF311E0", Offset = "0xF301E0", VA = "0x180F311E0", Slot = "30")]
		internal unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount, DecoderNLS baseDecoder)
		{
			return 0;
		}

		// Token: 0x060012C8 RID: 4808 RVA: 0x0000E7D8 File Offset: 0x0000C9D8
		[Token(Token = "0x60012C8")]
		[Address(RVA = "0xF320E0", Offset = "0xF310E0", VA = "0x180F320E0")]
		private uint GetSurrogate(char cHigh, char cLow)
		{
			return 0U;
		}

		// Token: 0x060012C9 RID: 4809 RVA: 0x0000E7F0 File Offset: 0x0000C9F0
		[Token(Token = "0x60012C9")]
		[Address(RVA = "0xF31BF0", Offset = "0xF30BF0", VA = "0x180F31BF0")]
		private char GetHighSurrogate(uint iChar)
		{
			return '\0';
		}

		// Token: 0x060012CA RID: 4810 RVA: 0x0000E808 File Offset: 0x0000CA08
		[Token(Token = "0x60012CA")]
		[Address(RVA = "0xF31C10", Offset = "0xF30C10", VA = "0x180F31C10")]
		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: 0x060012CB RID: 4811 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012CB")]
		[Address(RVA = "0xF31A90", Offset = "0xF30A90", VA = "0x180F31A90", 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: 0x060012CC RID: 4812 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012CC")]
		[Address(RVA = "0xF31AF0", Offset = "0xF30AF0", VA = "0x180F31AF0", 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: 0x060012CD RID: 4813 RVA: 0x0000E820 File Offset: 0x0000CA20
		[Token(Token = "0x60012CD")]
		[Address(RVA = "0xF31C30", Offset = "0xF30C30", VA = "0x180F31C30", 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: 0x060012CE RID: 4814 RVA: 0x0000E838 File Offset: 0x0000CA38
		[Token(Token = "0x60012CE")]
		[Address(RVA = "0xF31D60", Offset = "0xF30D60", VA = "0x180F31D60", 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: 0x060012CF RID: 4815 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60012CF")]
		[Address(RVA = "0xF31E40", Offset = "0xF30E40", VA = "0x180F31E40", 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: 0x060012D0 RID: 4816 RVA: 0x0000E850 File Offset: 0x0000CA50
		[Token(Token = "0x60012D0")]
		[Address(RVA = "0xF2F910", Offset = "0xF2E910", VA = "0x180F2F910", 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: 0x060012D1 RID: 4817 RVA: 0x0000E868 File Offset: 0x0000CA68
		[Token(Token = "0x60012D1")]
		[Address(RVA = "0xF31B50", Offset = "0xF30B50", VA = "0x180F31B50", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		// Token: 0x04000988 RID: 2440
		[FieldOffset(Offset = "0x38")]
		[Token(Token = "0x4000988")]
		private bool emitUTF32ByteOrderMark;

		// Token: 0x04000989 RID: 2441
		[FieldOffset(Offset = "0x39")]
		[Token(Token = "0x4000989")]
		private bool isThrowException;

		// Token: 0x0400098A RID: 2442
		[FieldOffset(Offset = "0x3A")]
		[Token(Token = "0x400098A")]
		private bool bigEndian;

		// Token: 0x020001E7 RID: 487
		[Token(Token = "0x20001E7")]
		[Serializable]
		internal class UTF32Decoder : DecoderNLS
		{
			// Token: 0x060012D2 RID: 4818 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012D2")]
			[Address(RVA = "0xF2ADF0", Offset = "0xF29DF0", VA = "0x180F2ADF0")]
			public UTF32Decoder(UTF32Encoding encoding)
			{
			}

			// Token: 0x060012D3 RID: 4819 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60012D3")]
			[Address(RVA = "0xF2F8D0", Offset = "0xF2E8D0", VA = "0x180F2F8D0", Slot = "4")]
			public override void Reset()
			{
			}

			// Token: 0x170001DF RID: 479
			// (get) Token: 0x060012D4 RID: 4820 RVA: 0x0000E880 File Offset: 0x0000CA80
			[Token(Token = "0x170001DF")]
			internal override bool HasState
			{
				[Token(Token = "0x60012D4")]
				[Address(RVA = "0xF2F900", Offset = "0xF2E900", VA = "0x180F2F900", Slot = "14")]
				get
				{
					return default(bool);
				}
			}

			// Token: 0x0400098B RID: 2443
			[FieldOffset(Offset = "0x30")]
			[Token(Token = "0x400098B")]
			internal int iChar;

			// Token: 0x0400098C RID: 2444
			[FieldOffset(Offset = "0x34")]
			[Token(Token = "0x400098C")]
			internal int readByteCount;
		}
	}
}