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

namespace System
{
	/// <summary>Converts a base data type to another base data type.</summary>
	// Token: 0x020000D5 RID: 213
	[Token(Token = "0x20000D5")]
	public static class Convert
	{
		/// <summary>Returns the <see cref="T:System.TypeCode" /> for the specified object.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <returns>The <see cref="T:System.TypeCode" /> for <paramref name="value" />, or <see cref="F:System.TypeCode.Empty" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		// Token: 0x0600062A RID: 1578 RVA: 0x00005100 File Offset: 0x00003300
		[Token(Token = "0x600062A")]
		[Address(RVA = "0x2C34B90", Offset = "0x2C33B90", VA = "0x182C34B90")]
		public static TypeCode GetTypeCode(object value)
		{
			return TypeCode.Empty;
		}

		/// <summary>Returns an object of the specified type whose value is equivalent to the specified object. A parameter supplies culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="typeCode">The type of object to return.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An object whose underlying type is <paramref name="typeCode" /> and whose value is equivalent to <paramref name="value" />.  
		///  -or-  
		///  A null reference (<see langword="Nothing" /> in Visual Basic), if <paramref name="value" /> is <see langword="null" /> and <paramref name="typeCode" /> is <see cref="F:System.TypeCode.Empty" />, <see cref="F:System.TypeCode.String" />, or <see cref="F:System.TypeCode.Object" />.</returns>
		/// <exception cref="T:System.InvalidCastException">This conversion is not supported.  
		///  -or-  
		///  <paramref name="value" /> is <see langword="null" /> and <paramref name="typeCode" /> specifies a value type.  
		///  -or-  
		///  <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in a format for the <paramref name="typeCode" /> type recognized by <paramref name="provider" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is out of the range of the <paramref name="typeCode" /> type.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="typeCode" /> is invalid.</exception>
		// Token: 0x0600062B RID: 1579 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600062B")]
		[Address(RVA = "0x2C31E30", Offset = "0x2C30E30", VA = "0x182C31E30")]
		public static object ChangeType(object value, TypeCode typeCode, IFormatProvider provider)
		{
			return null;
		}

		// Token: 0x0600062C RID: 1580 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600062C")]
		[Address(RVA = "0x2C333A0", Offset = "0x2C323A0", VA = "0x182C333A0")]
		internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Returns an object of the specified type and whose value is equivalent to the specified object.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="conversionType">The type of object to return.</param>
		/// <returns>An object whose type is <paramref name="conversionType" /> and whose value is equivalent to <paramref name="value" />.  
		///  -or-  
		///  A null reference (<see langword="Nothing" /> in Visual Basic), if <paramref name="value" /> is <see langword="null" /> and <paramref name="conversionType" /> is not a value type.</returns>
		/// <exception cref="T:System.InvalidCastException">This conversion is not supported.  
		///  -or-  
		///  <paramref name="value" /> is <see langword="null" /> and <paramref name="conversionType" /> is a value type.  
		///  -or-  
		///  <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in a format recognized by <paramref name="conversionType" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is out of the range of <paramref name="conversionType" />.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="conversionType" /> is <see langword="null" />.</exception>
		// Token: 0x0600062D RID: 1581 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600062D")]
		[Address(RVA = "0x2C33070", Offset = "0x2C32070", VA = "0x182C33070")]
		public static object ChangeType(object value, Type conversionType)
		{
			return null;
		}

		/// <summary>Returns an object of the specified type whose value is equivalent to the specified object. A parameter supplies culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="conversionType">The type of object to return.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An object whose type is <paramref name="conversionType" /> and whose value is equivalent to <paramref name="value" />.  
		///  -or-  
		///  <paramref name="value" />, if the <see cref="T:System.Type" /> of <paramref name="value" /> and <paramref name="conversionType" /> are equal.  
		///  -or-  
		///  A null reference (<see langword="Nothing" /> in Visual Basic), if <paramref name="value" /> is <see langword="null" /> and <paramref name="conversionType" /> is not a value type.</returns>
		/// <exception cref="T:System.InvalidCastException">This conversion is not supported.  
		///  -or-  
		///  <paramref name="value" /> is <see langword="null" /> and <paramref name="conversionType" /> is a value type.  
		///  -or-  
		///  <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in a format for <paramref name="conversionType" /> recognized by <paramref name="provider" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is out of the range of <paramref name="conversionType" />.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="conversionType" /> is <see langword="null" />.</exception>
		// Token: 0x0600062E RID: 1582 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600062E")]
		[Address(RVA = "0x2C32290", Offset = "0x2C31290", VA = "0x182C32290")]
		public static object ChangeType(object value, Type conversionType, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified object to an equivalent Boolean value, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>
		///   <see langword="true" /> or <see langword="false" />, which reflects the value returned by invoking the <see cref="M:System.IConvertible.ToBoolean(System.IFormatProvider)" /> method for the underlying type of <paramref name="value" />. If <paramref name="value" /> is <see langword="null" />, the method returns <see langword="false" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is a string that does not equal <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion of <paramref name="value" /> to a <see cref="T:System.Boolean" /> is not supported.</exception>
		// Token: 0x0600062F RID: 1583 RVA: 0x00005118 File Offset: 0x00003318
		[Token(Token = "0x600062F")]
		[Address(RVA = "0x2C356C0", Offset = "0x2C346C0", VA = "0x182C356C0")]
		public static bool ToBoolean(object value, IFormatProvider provider)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000630 RID: 1584 RVA: 0x00005130 File Offset: 0x00003330
		[Token(Token = "0x6000630")]
		[Address(RVA = "0x2C357D0", Offset = "0x2C347D0", VA = "0x182C357D0")]
		[CLSCompliant(false)]
		public static bool ToBoolean(sbyte value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000631 RID: 1585 RVA: 0x00005148 File Offset: 0x00003348
		[Token(Token = "0x6000631")]
		[Address(RVA = "0x2C357D0", Offset = "0x2C347D0", VA = "0x182C357D0")]
		public static bool ToBoolean(byte value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000632 RID: 1586 RVA: 0x00005160 File Offset: 0x00003360
		[Token(Token = "0x6000632")]
		[Address(RVA = "0x2C35610", Offset = "0x2C34610", VA = "0x182C35610")]
		public static bool ToBoolean(short value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000633 RID: 1587 RVA: 0x00005178 File Offset: 0x00003378
		[Token(Token = "0x6000633")]
		[Address(RVA = "0x2C35610", Offset = "0x2C34610", VA = "0x182C35610")]
		[CLSCompliant(false)]
		public static bool ToBoolean(ushort value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000634 RID: 1588 RVA: 0x00005190 File Offset: 0x00003390
		[Token(Token = "0x6000634")]
		[Address(RVA = "0x11085D0", Offset = "0x11075D0", VA = "0x1811085D0")]
		public static bool ToBoolean(int value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000635 RID: 1589 RVA: 0x000051A8 File Offset: 0x000033A8
		[Token(Token = "0x6000635")]
		[Address(RVA = "0x11085D0", Offset = "0x11075D0", VA = "0x1811085D0")]
		[CLSCompliant(false)]
		public static bool ToBoolean(uint value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000636 RID: 1590 RVA: 0x000051C0 File Offset: 0x000033C0
		[Token(Token = "0x6000636")]
		[Address(RVA = "0x77C860", Offset = "0x77B860", VA = "0x18077C860")]
		public static bool ToBoolean(long value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent Boolean value.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000637 RID: 1591 RVA: 0x000051D8 File Offset: 0x000033D8
		[Token(Token = "0x6000637")]
		[Address(RVA = "0x77C860", Offset = "0x77B860", VA = "0x18077C860")]
		[CLSCompliant(false)]
		public static bool ToBoolean(ulong value)
		{
			return default(bool);
		}

		/// <summary>Converts the specified string representation of a logical value to its Boolean equivalent.</summary>
		/// <param name="value">A string that contains the value of either <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> equals <see cref="F:System.Boolean.TrueString" />, or <see langword="false" /> if <paramref name="value" /> equals <see cref="F:System.Boolean.FalseString" /> or <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not equal to <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</exception>
		// Token: 0x06000638 RID: 1592 RVA: 0x000051F0 File Offset: 0x000033F0
		[Token(Token = "0x6000638")]
		[Address(RVA = "0x2C357E0", Offset = "0x2C347E0", VA = "0x182C357E0")]
		public static bool ToBoolean(string value)
		{
			return default(bool);
		}

		/// <summary>Converts the specified string representation of a logical value to its Boolean equivalent, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the value of either <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information. This parameter is ignored.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> equals <see cref="F:System.Boolean.TrueString" />, or <see langword="false" /> if <paramref name="value" /> equals <see cref="F:System.Boolean.FalseString" /> or <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not equal to <see cref="F:System.Boolean.TrueString" /> or <see cref="F:System.Boolean.FalseString" />.</exception>
		// Token: 0x06000639 RID: 1593 RVA: 0x00005208 File Offset: 0x00003408
		[Token(Token = "0x6000639")]
		[Address(RVA = "0x2C35770", Offset = "0x2C34770", VA = "0x182C35770")]
		public static bool ToBoolean(string value, IFormatProvider provider)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent Boolean value.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x0600063A RID: 1594 RVA: 0x00005220 File Offset: 0x00003420
		[Token(Token = "0x600063A")]
		[Address(RVA = "0x2C35840", Offset = "0x2C34840", VA = "0x182C35840")]
		public static bool ToBoolean(float value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent Boolean value.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x0600063B RID: 1595 RVA: 0x00005238 File Offset: 0x00003438
		[Token(Token = "0x600063B")]
		[Address(RVA = "0x2C35620", Offset = "0x2C34620", VA = "0x182C35620")]
		public static bool ToBoolean(double value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent Boolean value.</summary>
		/// <param name="value">The number to convert.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x0600063C RID: 1596 RVA: 0x00005250 File Offset: 0x00003450
		[Token(Token = "0x600063C")]
		[Address(RVA = "0x2C35640", Offset = "0x2C34640", VA = "0x182C35640")]
		public static bool ToBoolean(decimal value)
		{
			return default(bool);
		}

		/// <summary>Converts the value of the specified object to its equivalent Unicode character, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />, or <see cref="F:System.Char.MinValue" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is a null string.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion of <paramref name="value" /> to a <see cref="T:System.Char" /> is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Char.MinValue" /> or greater than <see cref="F:System.Char.MaxValue" />.</exception>
		// Token: 0x0600063D RID: 1597 RVA: 0x00005268 File Offset: 0x00003468
		[Token(Token = "0x600063D")]
		[Address(RVA = "0x2C36370", Offset = "0x2C35370", VA = "0x182C36370")]
		public static char ToChar(object value, IFormatProvider provider)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Char.MinValue" />.</exception>
		// Token: 0x0600063E RID: 1598 RVA: 0x00005280 File Offset: 0x00003480
		[Token(Token = "0x600063E")]
		[Address(RVA = "0x2C361F0", Offset = "0x2C351F0", VA = "0x182C361F0")]
		[CLSCompliant(false)]
		public static char ToChar(sbyte value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x0600063F RID: 1599 RVA: 0x00005298 File Offset: 0x00003498
		[Token(Token = "0x600063F")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		public static char ToChar(byte value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Char.MinValue" />.</exception>
		// Token: 0x06000640 RID: 1600 RVA: 0x000052B0 File Offset: 0x000034B0
		[Token(Token = "0x6000640")]
		[Address(RVA = "0x2C36420", Offset = "0x2C35420", VA = "0x182C36420")]
		public static char ToChar(short value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000641 RID: 1601 RVA: 0x000052C8 File Offset: 0x000034C8
		[Token(Token = "0x6000641")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static char ToChar(ushort value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Char.MinValue" /> or greater than <see cref="F:System.Char.MaxValue" />.</exception>
		// Token: 0x06000642 RID: 1602 RVA: 0x000052E0 File Offset: 0x000034E0
		[Token(Token = "0x6000642")]
		[Address(RVA = "0x2C36270", Offset = "0x2C35270", VA = "0x182C36270")]
		public static char ToChar(int value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Char.MaxValue" />.</exception>
		// Token: 0x06000643 RID: 1603 RVA: 0x000052F8 File Offset: 0x000034F8
		[Token(Token = "0x6000643")]
		[Address(RVA = "0x2C36170", Offset = "0x2C35170", VA = "0x182C36170")]
		[CLSCompliant(false)]
		public static char ToChar(uint value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Char.MinValue" /> or greater than <see cref="F:System.Char.MaxValue" />.</exception>
		// Token: 0x06000644 RID: 1604 RVA: 0x00005310 File Offset: 0x00003510
		[Token(Token = "0x6000644")]
		[Address(RVA = "0x2C362F0", Offset = "0x2C352F0", VA = "0x182C362F0")]
		public static char ToChar(long value)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to its equivalent Unicode character.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A Unicode character that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Char.MaxValue" />.</exception>
		// Token: 0x06000645 RID: 1605 RVA: 0x00005328 File Offset: 0x00003528
		[Token(Token = "0x6000645")]
		[Address(RVA = "0x2C36560", Offset = "0x2C35560", VA = "0x182C36560")]
		[CLSCompliant(false)]
		public static char ToChar(ulong value)
		{
			return '\0';
		}

		/// <summary>Converts the first character of a specified string to a Unicode character.</summary>
		/// <param name="value">A string of length 1.</param>
		/// <returns>A Unicode character that is equivalent to the first and only character in <paramref name="value" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">The length of <paramref name="value" /> is not 1.</exception>
		// Token: 0x06000646 RID: 1606 RVA: 0x00005340 File Offset: 0x00003540
		[Token(Token = "0x6000646")]
		[Address(RVA = "0x2C365E0", Offset = "0x2C355E0", VA = "0x182C365E0")]
		public static char ToChar(string value)
		{
			return '\0';
		}

		/// <summary>Converts the first character of a specified string to a Unicode character, using specified culture-specific formatting information.</summary>
		/// <param name="value">A string of length 1 or <see langword="null" />.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information. This parameter is ignored.</param>
		/// <returns>A Unicode character that is equivalent to the first and only character in <paramref name="value" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">The length of <paramref name="value" /> is not 1.</exception>
		// Token: 0x06000647 RID: 1607 RVA: 0x00005358 File Offset: 0x00003558
		[Token(Token = "0x6000647")]
		[Address(RVA = "0x2C364A0", Offset = "0x2C354A0", VA = "0x182C364A0")]
		public static char ToChar(string value, IFormatProvider provider)
		{
			return '\0';
		}

		/// <summary>Converts the value of the specified object to an 8-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.SByte.MinValue" /> or greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x06000648 RID: 1608 RVA: 0x00005370 File Offset: 0x00003570
		[Token(Token = "0x6000648")]
		[Address(RVA = "0x2C38780", Offset = "0x2C37780", VA = "0x182C38780")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(object value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000649 RID: 1609 RVA: 0x00005388 File Offset: 0x00003588
		[Token(Token = "0x6000649")]
		[Address(RVA = "0x2C357D0", Offset = "0x2C347D0", VA = "0x182C357D0")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(bool value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x0600064A RID: 1610 RVA: 0x000053A0 File Offset: 0x000035A0
		[Token(Token = "0x600064A")]
		[Address(RVA = "0x2C38670", Offset = "0x2C37670", VA = "0x182C38670")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(char value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x0600064B RID: 1611 RVA: 0x000053B8 File Offset: 0x000035B8
		[Token(Token = "0x600064B")]
		[Address(RVA = "0x2C38B10", Offset = "0x2C37B10", VA = "0x182C38B10")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(byte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x0600064C RID: 1612 RVA: 0x000053D0 File Offset: 0x000035D0
		[Token(Token = "0x600064C")]
		[Address(RVA = "0x2C38C20", Offset = "0x2C37C20", VA = "0x182C38C20")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(short value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x0600064D RID: 1613 RVA: 0x000053E8 File Offset: 0x000035E8
		[Token(Token = "0x600064D")]
		[Address(RVA = "0x2C38990", Offset = "0x2C37990", VA = "0x182C38990")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(ushort value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x0600064E RID: 1614 RVA: 0x00005400 File Offset: 0x00003600
		[Token(Token = "0x600064E")]
		[Address(RVA = "0x2C38A90", Offset = "0x2C37A90", VA = "0x182C38A90")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(int value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x0600064F RID: 1615 RVA: 0x00005418 File Offset: 0x00003618
		[Token(Token = "0x600064F")]
		[Address(RVA = "0x2C38910", Offset = "0x2C37910", VA = "0x182C38910")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(uint value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000650 RID: 1616 RVA: 0x00005430 File Offset: 0x00003630
		[Token(Token = "0x6000650")]
		[Address(RVA = "0x2C386F0", Offset = "0x2C376F0", VA = "0x182C386F0")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(long value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000651 RID: 1617 RVA: 0x00005448 File Offset: 0x00003648
		[Token(Token = "0x6000651")]
		[Address(RVA = "0x2C38A10", Offset = "0x2C37A10", VA = "0x182C38A10")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(ulong value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000652 RID: 1618 RVA: 0x00005460 File Offset: 0x00003660
		[Token(Token = "0x6000652")]
		[Address(RVA = "0x2C38CB0", Offset = "0x2C37CB0", VA = "0x182C38CB0")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(float value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000653 RID: 1619 RVA: 0x00005478 File Offset: 0x00003678
		[Token(Token = "0x6000653")]
		[Address(RVA = "0x2C38830", Offset = "0x2C37830", VA = "0x182C38830")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(double value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.SByte.MaxValue" /> or less than <see cref="F:System.SByte.MinValue" />.</exception>
		// Token: 0x06000654 RID: 1620 RVA: 0x00005490 File Offset: 0x00003690
		[Token(Token = "0x6000654")]
		[Address(RVA = "0x2C38B90", Offset = "0x2C37B90", VA = "0x182C38B90")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 8-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="value" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.SByte.MinValue" /> or greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x06000655 RID: 1621 RVA: 0x000054A8 File Offset: 0x000036A8
		[Token(Token = "0x6000655")]
		[Address(RVA = "0x2C38C10", Offset = "0x2C37C10", VA = "0x182C38C10")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(string value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to an 8-bit unsigned integer.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in the property format for a <see cref="T:System.Byte" /> value.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement <see cref="T:System.IConvertible" />.  
		/// -or-  
		/// Conversion from <paramref name="value" /> to the <see cref="T:System.Byte" /> type is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000656 RID: 1622 RVA: 0x000054C0 File Offset: 0x000036C0
		[Token(Token = "0x6000656")]
		[Address(RVA = "0x2C35850", Offset = "0x2C34850", VA = "0x182C35850")]
		public static byte ToByte(object value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to an 8-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in the property format for a <see cref="T:System.Byte" /> value.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement <see cref="T:System.IConvertible" />.  
		/// -or-  
		/// Conversion from <paramref name="value" /> to the <see cref="T:System.Byte" /> type is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000657 RID: 1623 RVA: 0x000054D8 File Offset: 0x000036D8
		[Token(Token = "0x6000657")]
		[Address(RVA = "0x2C35BD0", Offset = "0x2C34BD0", VA = "0x182C35BD0")]
		public static byte ToByte(object value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000658 RID: 1624 RVA: 0x000054F0 File Offset: 0x000036F0
		[Token(Token = "0x6000658")]
		[Address(RVA = "0x2C357D0", Offset = "0x2C347D0", VA = "0x182C357D0")]
		public static byte ToByte(bool value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000659 RID: 1625 RVA: 0x00005508 File Offset: 0x00003708
		[Token(Token = "0x6000659")]
		[Address(RVA = "0x2C36080", Offset = "0x2C35080", VA = "0x182C36080")]
		public static byte ToByte(char value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit signed integer to be converted.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Byte.MinValue" />.</exception>
		// Token: 0x0600065A RID: 1626 RVA: 0x00005520 File Offset: 0x00003720
		[Token(Token = "0x600065A")]
		[Address(RVA = "0x2C35C80", Offset = "0x2C34C80", VA = "0x182C35C80")]
		[CLSCompliant(false)]
		public static byte ToByte(sbyte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x0600065B RID: 1627 RVA: 0x00005538 File Offset: 0x00003738
		[Token(Token = "0x600065B")]
		[Address(RVA = "0x2C358F0", Offset = "0x2C348F0", VA = "0x182C358F0")]
		public static byte ToByte(short value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x0600065C RID: 1628 RVA: 0x00005550 File Offset: 0x00003750
		[Token(Token = "0x600065C")]
		[Address(RVA = "0x2C35970", Offset = "0x2C34970", VA = "0x182C35970")]
		[CLSCompliant(false)]
		public static byte ToByte(ushort value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x0600065D RID: 1629 RVA: 0x00005568 File Offset: 0x00003768
		[Token(Token = "0x600065D")]
		[Address(RVA = "0x2C35FE0", Offset = "0x2C34FE0", VA = "0x182C35FE0")]
		public static byte ToByte(int value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x0600065E RID: 1630 RVA: 0x00005580 File Offset: 0x00003780
		[Token(Token = "0x600065E")]
		[Address(RVA = "0x2C359F0", Offset = "0x2C349F0", VA = "0x182C359F0")]
		[CLSCompliant(false)]
		public static byte ToByte(uint value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x0600065F RID: 1631 RVA: 0x00005598 File Offset: 0x00003798
		[Token(Token = "0x600065F")]
		[Address(RVA = "0x2C35A70", Offset = "0x2C34A70", VA = "0x182C35A70")]
		public static byte ToByte(long value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000660 RID: 1632 RVA: 0x000055B0 File Offset: 0x000037B0
		[Token(Token = "0x6000660")]
		[Address(RVA = "0x2C35E50", Offset = "0x2C34E50", VA = "0x182C35E50")]
		[CLSCompliant(false)]
		public static byte ToByte(ulong value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">A single-precision floating-point number.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" /> or less than <see cref="F:System.Byte.MinValue" />.</exception>
		// Token: 0x06000661 RID: 1633 RVA: 0x000055C8 File Offset: 0x000037C8
		[Token(Token = "0x6000661")]
		[Address(RVA = "0x2C35ED0", Offset = "0x2C34ED0", VA = "0x182C35ED0")]
		public static byte ToByte(float value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" /> or less than <see cref="F:System.Byte.MinValue" />.</exception>
		// Token: 0x06000662 RID: 1634 RVA: 0x000055E0 File Offset: 0x000037E0
		[Token(Token = "0x6000662")]
		[Address(RVA = "0x2C35D00", Offset = "0x2C34D00", VA = "0x182C35D00")]
		public static byte ToByte(double value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 8-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Byte.MaxValue" /> or less than <see cref="F:System.Byte.MinValue" />.</exception>
		// Token: 0x06000663 RID: 1635 RVA: 0x000055F8 File Offset: 0x000037F8
		[Token(Token = "0x6000663")]
		[Address(RVA = "0x2C35DD0", Offset = "0x2C34DD0", VA = "0x182C35DD0")]
		public static byte ToByte(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000664 RID: 1636 RVA: 0x00005610 File Offset: 0x00003810
		[Token(Token = "0x6000664")]
		[Address(RVA = "0x2C36100", Offset = "0x2C35100", VA = "0x182C36100")]
		public static byte ToByte(string value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 8-bit unsigned integer, using specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x06000665 RID: 1637 RVA: 0x00005628 File Offset: 0x00003828
		[Token(Token = "0x6000665")]
		[Address(RVA = "0x2C36060", Offset = "0x2C35060", VA = "0x182C36060")]
		public static byte ToByte(string value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to a 16-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format for an <see cref="T:System.Int16" /> type.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement <see cref="T:System.IConvertible" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int16.MinValue" /> or greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x06000666 RID: 1638 RVA: 0x00005640 File Offset: 0x00003840
		[Token(Token = "0x6000666")]
		[Address(RVA = "0x2C376C0", Offset = "0x2C366C0", VA = "0x182C376C0")]
		public static short ToInt16(object value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000667 RID: 1639 RVA: 0x00005658 File Offset: 0x00003858
		[Token(Token = "0x6000667")]
		[Address(RVA = "0x2C379E0", Offset = "0x2C369E0", VA = "0x182C379E0")]
		public static short ToInt16(bool value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x06000668 RID: 1640 RVA: 0x00005670 File Offset: 0x00003870
		[Token(Token = "0x6000668")]
		[Address(RVA = "0x2C37770", Offset = "0x2C36770", VA = "0x182C37770")]
		public static short ToInt16(char value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000669 RID: 1641 RVA: 0x00005688 File Offset: 0x00003888
		[Token(Token = "0x6000669")]
		[Address(RVA = "0x2C37510", Offset = "0x2C36510", VA = "0x182C37510")]
		[CLSCompliant(false)]
		public static short ToInt16(sbyte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x0600066A RID: 1642 RVA: 0x000056A0 File Offset: 0x000038A0
		[Token(Token = "0x600066A")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		public static short ToInt16(byte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x0600066B RID: 1643 RVA: 0x000056B8 File Offset: 0x000038B8
		[Token(Token = "0x600066B")]
		[Address(RVA = "0x2C37520", Offset = "0x2C36520", VA = "0x182C37520")]
		[CLSCompliant(false)]
		public static short ToInt16(ushort value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>The 16-bit signed integer equivalent of <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x0600066C RID: 1644 RVA: 0x000056D0 File Offset: 0x000038D0
		[Token(Token = "0x600066C")]
		[Address(RVA = "0x2C37300", Offset = "0x2C36300", VA = "0x182C37300")]
		public static short ToInt16(int value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x0600066D RID: 1645 RVA: 0x000056E8 File Offset: 0x000038E8
		[Token(Token = "0x600066D")]
		[Address(RVA = "0x2C379F0", Offset = "0x2C369F0", VA = "0x182C379F0")]
		[CLSCompliant(false)]
		public static short ToInt16(uint value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x0600066E RID: 1646 RVA: 0x00005700 File Offset: 0x00003900
		[Token(Token = "0x600066E")]
		[Address(RVA = "0x2C37460", Offset = "0x2C36460", VA = "0x182C37460")]
		public static short ToInt16(long value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x0600066F RID: 1647 RVA: 0x00005718 File Offset: 0x00003918
		[Token(Token = "0x600066F")]
		[Address(RVA = "0x2C37870", Offset = "0x2C36870", VA = "0x182C37870")]
		[CLSCompliant(false)]
		public static short ToInt16(ulong value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x06000670 RID: 1648 RVA: 0x00005730 File Offset: 0x00003930
		[Token(Token = "0x6000670")]
		[Address(RVA = "0x2C375A0", Offset = "0x2C365A0", VA = "0x182C375A0")]
		public static short ToInt16(float value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x06000671 RID: 1649 RVA: 0x00005748 File Offset: 0x00003948
		[Token(Token = "0x6000671")]
		[Address(RVA = "0x2C37380", Offset = "0x2C36380", VA = "0x182C37380")]
		public static short ToInt16(double value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int16.MaxValue" /> or less than <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x06000672 RID: 1650 RVA: 0x00005760 File Offset: 0x00003960
		[Token(Token = "0x6000672")]
		[Address(RVA = "0x2C377F0", Offset = "0x2C367F0", VA = "0x182C377F0")]
		public static short ToInt16(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 16-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 16-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int16.MinValue" /> or greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x06000673 RID: 1651 RVA: 0x00005778 File Offset: 0x00003978
		[Token(Token = "0x6000673")]
		[Address(RVA = "0x2C374F0", Offset = "0x2C364F0", VA = "0x182C374F0")]
		public static short ToInt16(string value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to a 16-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the  <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt16.MinValue" /> or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x06000674 RID: 1652 RVA: 0x00005790 File Offset: 0x00003990
		[Token(Token = "0x6000674")]
		[Address(RVA = "0x2C39BD0", Offset = "0x2C38BD0", VA = "0x182C39BD0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(object value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000675 RID: 1653 RVA: 0x000057A8 File Offset: 0x000039A8
		[Token(Token = "0x6000675")]
		[Address(RVA = "0x2C379E0", Offset = "0x2C369E0", VA = "0x182C379E0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(bool value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>The 16-bit unsigned integer equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000676 RID: 1654 RVA: 0x000057C0 File Offset: 0x000039C0
		[Token(Token = "0x6000676")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(char value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x06000677 RID: 1655 RVA: 0x000057D8 File Offset: 0x000039D8
		[Token(Token = "0x6000677")]
		[Address(RVA = "0x2C399B0", Offset = "0x2C389B0", VA = "0x182C399B0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(sbyte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000678 RID: 1656 RVA: 0x000057F0 File Offset: 0x000039F0
		[Token(Token = "0x6000678")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(byte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x06000679 RID: 1657 RVA: 0x00005808 File Offset: 0x00003A08
		[Token(Token = "0x6000679")]
		[Address(RVA = "0x2C39A30", Offset = "0x2C38A30", VA = "0x182C39A30")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(short value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067A RID: 1658 RVA: 0x00005820 File Offset: 0x00003A20
		[Token(Token = "0x600067A")]
		[Address(RVA = "0x2C39AB0", Offset = "0x2C38AB0", VA = "0x182C39AB0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(int value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067B RID: 1659 RVA: 0x00005838 File Offset: 0x00003A38
		[Token(Token = "0x600067B")]
		[Address(RVA = "0x2C39930", Offset = "0x2C38930", VA = "0x182C39930")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(uint value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067C RID: 1660 RVA: 0x00005850 File Offset: 0x00003A50
		[Token(Token = "0x600067C")]
		[Address(RVA = "0x2C39B30", Offset = "0x2C38B30", VA = "0x182C39B30")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(long value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067D RID: 1661 RVA: 0x00005868 File Offset: 0x00003A68
		[Token(Token = "0x600067D")]
		[Address(RVA = "0x2C39D50", Offset = "0x2C38D50", VA = "0x182C39D50")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(ulong value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067E RID: 1662 RVA: 0x00005880 File Offset: 0x00003A80
		[Token(Token = "0x600067E")]
		[Address(RVA = "0x2C39820", Offset = "0x2C38820", VA = "0x182C39820")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(float value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x0600067F RID: 1663 RVA: 0x00005898 File Offset: 0x00003A98
		[Token(Token = "0x600067F")]
		[Address(RVA = "0x2C39C80", Offset = "0x2C38C80", VA = "0x182C39C80")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(double value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 16-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x06000680 RID: 1664 RVA: 0x000058B0 File Offset: 0x00003AB0
		[Token(Token = "0x6000680")]
		[Address(RVA = "0x2C397A0", Offset = "0x2C387A0", VA = "0x182C397A0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 16-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt16.MinValue" /> or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x06000681 RID: 1665 RVA: 0x000058C8 File Offset: 0x00003AC8
		[Token(Token = "0x6000681")]
		[Address(RVA = "0x2C39BB0", Offset = "0x2C38BB0", VA = "0x182C39BB0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(string value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to a 32-bit signed integer.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <returns>A 32-bit signed integer equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the  <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000682 RID: 1666 RVA: 0x000058E0 File Offset: 0x00003AE0
		[Token(Token = "0x6000682")]
		[Address(RVA = "0x2C37FB0", Offset = "0x2C36FB0", VA = "0x182C37FB0")]
		public static int ToInt32(object value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to a 32-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement <see cref="T:System.IConvertible" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000683 RID: 1667 RVA: 0x000058F8 File Offset: 0x00003AF8
		[Token(Token = "0x6000683")]
		[Address(RVA = "0x2C37CF0", Offset = "0x2C36CF0", VA = "0x182C37CF0")]
		public static int ToInt32(object value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 32-bit signed integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000684 RID: 1668 RVA: 0x00005910 File Offset: 0x00003B10
		[Token(Token = "0x6000684")]
		[Address(RVA = "0x11D1440", Offset = "0x11D0440", VA = "0x1811D1440")]
		public static int ToInt32(bool value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 32-bit signed integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000685 RID: 1669 RVA: 0x00005928 File Offset: 0x00003B28
		[Token(Token = "0x6000685")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		public static int ToInt32(char value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000686 RID: 1670 RVA: 0x00005940 File Offset: 0x00003B40
		[Token(Token = "0x6000686")]
		[Address(RVA = "0x2C37510", Offset = "0x2C36510", VA = "0x182C37510")]
		[CLSCompliant(false)]
		public static int ToInt32(sbyte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000687 RID: 1671 RVA: 0x00005958 File Offset: 0x00003B58
		[Token(Token = "0x6000687")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		public static int ToInt32(byte value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000688 RID: 1672 RVA: 0x00005970 File Offset: 0x00003B70
		[Token(Token = "0x6000688")]
		[Address(RVA = "0x270C460", Offset = "0x270B460", VA = "0x18270C460")]
		public static int ToInt32(short value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000689 RID: 1673 RVA: 0x00005988 File Offset: 0x00003B88
		[Token(Token = "0x6000689")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static int ToInt32(ushort value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x0600068A RID: 1674 RVA: 0x000059A0 File Offset: 0x00003BA0
		[Token(Token = "0x600068A")]
		[Address(RVA = "0x2C37EB0", Offset = "0x2C36EB0", VA = "0x182C37EB0")]
		[CLSCompliant(false)]
		public static int ToInt32(uint value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" /> or less than <see cref="F:System.Int32.MinValue" />.</exception>
		// Token: 0x0600068B RID: 1675 RVA: 0x000059B8 File Offset: 0x00003BB8
		[Token(Token = "0x600068B")]
		[Address(RVA = "0x2C37C60", Offset = "0x2C36C60", VA = "0x182C37C60")]
		public static int ToInt32(long value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x0600068C RID: 1676 RVA: 0x000059D0 File Offset: 0x00003BD0
		[Token(Token = "0x600068C")]
		[Address(RVA = "0x2C37BE0", Offset = "0x2C36BE0", VA = "0x182C37BE0")]
		[CLSCompliant(false)]
		public static int ToInt32(ulong value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" /> or less than <see cref="F:System.Int32.MinValue" />.</exception>
		// Token: 0x0600068D RID: 1677 RVA: 0x000059E8 File Offset: 0x00003BE8
		[Token(Token = "0x600068D")]
		[Address(RVA = "0x2C37F30", Offset = "0x2C36F30", VA = "0x182C37F30")]
		public static int ToInt32(float value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" /> or less than <see cref="F:System.Int32.MinValue" />.</exception>
		// Token: 0x0600068E RID: 1678 RVA: 0x00005A00 File Offset: 0x00003C00
		[Token(Token = "0x600068E")]
		[Address(RVA = "0x2C37A70", Offset = "0x2C36A70", VA = "0x182C37A70")]
		public static int ToInt32(double value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int32.MaxValue" /> or less than <see cref="F:System.Int32.MinValue" />.</exception>
		// Token: 0x0600068F RID: 1679 RVA: 0x00005A18 File Offset: 0x00003C18
		[Token(Token = "0x600068F")]
		[Address(RVA = "0x2C37B80", Offset = "0x2C36B80", VA = "0x182C37B80")]
		public static int ToInt32(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <returns>A 32-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000690 RID: 1680 RVA: 0x00005A30 File Offset: 0x00003C30
		[Token(Token = "0x6000690")]
		[Address(RVA = "0x2C37E40", Offset = "0x2C36E40", VA = "0x182C37E40")]
		public static int ToInt32(string value)
		{
			return 0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 32-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 32-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000691 RID: 1681 RVA: 0x00005A48 File Offset: 0x00003C48
		[Token(Token = "0x6000691")]
		[Address(RVA = "0x2C37F90", Offset = "0x2C36F90", VA = "0x182C37F90")]
		public static int ToInt32(string value, IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified object to a 32-bit unsigned integer.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt32.MinValue" /> or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x06000692 RID: 1682 RVA: 0x00005A60 File Offset: 0x00003C60
		[Token(Token = "0x6000692")]
		[Address(RVA = "0x2C39FD0", Offset = "0x2C38FD0", VA = "0x182C39FD0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(object value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified object to a 32-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt32.MinValue" /> or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x06000693 RID: 1683 RVA: 0x00005A78 File Offset: 0x00003C78
		[Token(Token = "0x6000693")]
		[Address(RVA = "0x2C3A1F0", Offset = "0x2C391F0", VA = "0x182C3A1F0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(object value, IFormatProvider provider)
		{
			return 0U;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x06000694 RID: 1684 RVA: 0x00005A90 File Offset: 0x00003C90
		[Token(Token = "0x6000694")]
		[Address(RVA = "0x11D1440", Offset = "0x11D0440", VA = "0x1811D1440")]
		[CLSCompliant(false)]
		public static uint ToUInt32(bool value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000695 RID: 1685 RVA: 0x00005AA8 File Offset: 0x00003CA8
		[Token(Token = "0x6000695")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(char value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x06000696 RID: 1686 RVA: 0x00005AC0 File Offset: 0x00003CC0
		[Token(Token = "0x6000696")]
		[Address(RVA = "0x2C3A070", Offset = "0x2C39070", VA = "0x182C3A070")]
		[CLSCompliant(false)]
		public static uint ToUInt32(sbyte value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000697 RID: 1687 RVA: 0x00005AD8 File Offset: 0x00003CD8
		[Token(Token = "0x6000697")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		[CLSCompliant(false)]
		public static uint ToUInt32(byte value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x06000698 RID: 1688 RVA: 0x00005AF0 File Offset: 0x00003CF0
		[Token(Token = "0x6000698")]
		[Address(RVA = "0x2C3A370", Offset = "0x2C39370", VA = "0x182C3A370")]
		[CLSCompliant(false)]
		public static uint ToUInt32(short value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x06000699 RID: 1689 RVA: 0x00005B08 File Offset: 0x00003D08
		[Token(Token = "0x6000699")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(ushort value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x0600069A RID: 1690 RVA: 0x00005B20 File Offset: 0x00003D20
		[Token(Token = "0x600069A")]
		[Address(RVA = "0x2C3A170", Offset = "0x2C39170", VA = "0x182C3A170")]
		[CLSCompliant(false)]
		public static uint ToUInt32(int value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x0600069B RID: 1691 RVA: 0x00005B38 File Offset: 0x00003D38
		[Token(Token = "0x600069B")]
		[Address(RVA = "0x2C3A410", Offset = "0x2C39410", VA = "0x182C3A410")]
		[CLSCompliant(false)]
		public static uint ToUInt32(long value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x0600069C RID: 1692 RVA: 0x00005B50 File Offset: 0x00003D50
		[Token(Token = "0x600069C")]
		[Address(RVA = "0x2C3A0F0", Offset = "0x2C390F0", VA = "0x182C3A0F0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(ulong value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x0600069D RID: 1693 RVA: 0x00005B68 File Offset: 0x00003D68
		[Token(Token = "0x600069D")]
		[Address(RVA = "0x2C3A490", Offset = "0x2C39490", VA = "0x182C3A490")]
		[CLSCompliant(false)]
		public static uint ToUInt32(float value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x0600069E RID: 1694 RVA: 0x00005B80 File Offset: 0x00003D80
		[Token(Token = "0x600069E")]
		[Address(RVA = "0x2C3A2A0", Offset = "0x2C392A0", VA = "0x182C3A2A0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(double value)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 32-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x0600069F RID: 1695 RVA: 0x00005B98 File Offset: 0x00003D98
		[Token(Token = "0x600069F")]
		[Address(RVA = "0x2C39EB0", Offset = "0x2C38EB0", VA = "0x182C39EB0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(decimal value)
		{
			return 0U;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 32-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt32.MinValue" /> or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x060006A0 RID: 1696 RVA: 0x00005BB0 File Offset: 0x00003DB0
		[Token(Token = "0x60006A0")]
		[Address(RVA = "0x2C3A3F0", Offset = "0x2C393F0", VA = "0x182C3A3F0")]
		[CLSCompliant(false)]
		public static uint ToUInt32(string value, IFormatProvider provider)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified object to a 64-bit signed integer.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060006A1 RID: 1697 RVA: 0x00005BC8 File Offset: 0x00003DC8
		[Token(Token = "0x60006A1")]
		[Address(RVA = "0x2C38110", Offset = "0x2C37110", VA = "0x182C38110")]
		public static long ToInt64(object value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified object to a 64-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060006A2 RID: 1698 RVA: 0x00005BE0 File Offset: 0x00003DE0
		[Token(Token = "0x60006A2")]
		[Address(RVA = "0x2C384B0", Offset = "0x2C374B0", VA = "0x182C384B0")]
		public static long ToInt64(object value, IFormatProvider provider)
		{
			return 0L;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 64-bit signed integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x060006A3 RID: 1699 RVA: 0x00005BF8 File Offset: 0x00003DF8
		[Token(Token = "0x60006A3")]
		[Address(RVA = "0x2C38560", Offset = "0x2C37560", VA = "0x182C38560")]
		public static long ToInt64(bool value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 64-bit signed integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A4 RID: 1700 RVA: 0x00005C10 File Offset: 0x00003E10
		[Token(Token = "0x60006A4")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		public static long ToInt64(char value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A5 RID: 1701 RVA: 0x00005C28 File Offset: 0x00003E28
		[Token(Token = "0x60006A5")]
		[Address(RVA = "0x2C38570", Offset = "0x2C37570", VA = "0x182C38570")]
		[CLSCompliant(false)]
		public static long ToInt64(sbyte value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A6 RID: 1702 RVA: 0x00005C40 File Offset: 0x00003E40
		[Token(Token = "0x60006A6")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		public static long ToInt64(byte value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A7 RID: 1703 RVA: 0x00005C58 File Offset: 0x00003E58
		[Token(Token = "0x60006A7")]
		[Address(RVA = "0x2C38050", Offset = "0x2C37050", VA = "0x182C38050")]
		public static long ToInt64(short value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A8 RID: 1704 RVA: 0x00005C70 File Offset: 0x00003E70
		[Token(Token = "0x60006A8")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static long ToInt64(ushort value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006A9 RID: 1705 RVA: 0x00005C88 File Offset: 0x00003E88
		[Token(Token = "0x60006A9")]
		[Address(RVA = "0x2C381B0", Offset = "0x2C371B0", VA = "0x182C381B0")]
		public static long ToInt64(int value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006AA RID: 1706 RVA: 0x00005CA0 File Offset: 0x00003EA0
		[Token(Token = "0x60006AA")]
		[Address(RVA = "0x593060", Offset = "0x592060", VA = "0x180593060")]
		[CLSCompliant(false)]
		public static long ToInt64(uint value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060006AB RID: 1707 RVA: 0x00005CB8 File Offset: 0x00003EB8
		[Token(Token = "0x60006AB")]
		[Address(RVA = "0x2C38060", Offset = "0x2C37060", VA = "0x182C38060")]
		[CLSCompliant(false)]
		public static long ToInt64(ulong value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int64.MaxValue" /> or less than <see cref="F:System.Int64.MinValue" />.</exception>
		// Token: 0x060006AC RID: 1708 RVA: 0x00005CD0 File Offset: 0x00003ED0
		[Token(Token = "0x60006AC")]
		[Address(RVA = "0x2C382D0", Offset = "0x2C372D0", VA = "0x182C382D0")]
		public static long ToInt64(float value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int64.MaxValue" /> or less than <see cref="F:System.Int64.MinValue" />.</exception>
		// Token: 0x060006AD RID: 1709 RVA: 0x00005CE8 File Offset: 0x00003EE8
		[Token(Token = "0x60006AD")]
		[Address(RVA = "0x2C381C0", Offset = "0x2C371C0", VA = "0x182C381C0")]
		public static long ToInt64(double value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit signed integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Int64.MaxValue" /> or less than <see cref="F:System.Int64.MinValue" />.</exception>
		// Token: 0x060006AE RID: 1710 RVA: 0x00005D00 File Offset: 0x00003F00
		[Token(Token = "0x60006AE")]
		[Address(RVA = "0x2C38250", Offset = "0x2C37250", VA = "0x182C38250")]
		public static long ToInt64(decimal value)
		{
			return 0L;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">A string that contains a number to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060006AF RID: 1711 RVA: 0x00005D18 File Offset: 0x00003F18
		[Token(Token = "0x60006AF")]
		[Address(RVA = "0x2C38440", Offset = "0x2C37440", VA = "0x182C38440")]
		public static long ToInt64(string value)
		{
			return 0L;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 64-bit signed integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 64-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060006B0 RID: 1712 RVA: 0x00005D30 File Offset: 0x00003F30
		[Token(Token = "0x60006B0")]
		[Address(RVA = "0x2C380F0", Offset = "0x2C370F0", VA = "0x182C380F0")]
		public static long ToInt64(string value, IFormatProvider provider)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified object to a 64-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt64.MinValue" /> or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006B1 RID: 1713 RVA: 0x00005D48 File Offset: 0x00003F48
		[Token(Token = "0x60006B1")]
		[Address(RVA = "0x2C3A990", Offset = "0x2C39990", VA = "0x182C3A990")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(object value, IFormatProvider provider)
		{
			return 0UL;
		}

		/// <summary>Converts the specified Boolean value to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x060006B2 RID: 1714 RVA: 0x00005D60 File Offset: 0x00003F60
		[Token(Token = "0x60006B2")]
		[Address(RVA = "0x11D1440", Offset = "0x11D0440", VA = "0x1811D1440")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(bool value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified Unicode character to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006B3 RID: 1715 RVA: 0x00005D78 File Offset: 0x00003F78
		[Token(Token = "0x60006B3")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(char value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x060006B4 RID: 1716 RVA: 0x00005D90 File Offset: 0x00003F90
		[Token(Token = "0x60006B4")]
		[Address(RVA = "0x2C3A610", Offset = "0x2C39610", VA = "0x182C3A610")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(sbyte value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006B5 RID: 1717 RVA: 0x00005DA8 File Offset: 0x00003FA8
		[Token(Token = "0x60006B5")]
		[Address(RVA = "0x270C450", Offset = "0x270B450", VA = "0x18270C450")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(byte value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x060006B6 RID: 1718 RVA: 0x00005DC0 File Offset: 0x00003FC0
		[Token(Token = "0x60006B6")]
		[Address(RVA = "0x2C3A850", Offset = "0x2C39850", VA = "0x182C3A850")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(short value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006B7 RID: 1719 RVA: 0x00005DD8 File Offset: 0x00003FD8
		[Token(Token = "0x60006B7")]
		[Address(RVA = "0xB4EEA0", Offset = "0xB4DEA0", VA = "0x180B4EEA0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(ushort value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x060006B8 RID: 1720 RVA: 0x00005DF0 File Offset: 0x00003FF0
		[Token(Token = "0x60006B8")]
		[Address(RVA = "0x2C3A690", Offset = "0x2C39690", VA = "0x182C3A690")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(int value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006B9 RID: 1721 RVA: 0x00005E08 File Offset: 0x00004008
		[Token(Token = "0x60006B9")]
		[Address(RVA = "0x593060", Offset = "0x592060", VA = "0x180593060")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(uint value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero.</exception>
		// Token: 0x060006BA RID: 1722 RVA: 0x00005E20 File Offset: 0x00004020
		[Token(Token = "0x60006BA")]
		[Address(RVA = "0x2C3AB30", Offset = "0x2C39B30", VA = "0x182C3AB30")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(long value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006BB RID: 1723 RVA: 0x00005E38 File Offset: 0x00004038
		[Token(Token = "0x60006BB")]
		[Address(RVA = "0x2C3AA40", Offset = "0x2C39A40", VA = "0x182C3AA40")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(float value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006BC RID: 1724 RVA: 0x00005E50 File Offset: 0x00004050
		[Token(Token = "0x60006BC")]
		[Address(RVA = "0x2C3A8D0", Offset = "0x2C398D0", VA = "0x182C3A8D0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(double value)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>
		///   <paramref name="value" />, rounded to the nearest 64-bit unsigned integer. If <paramref name="value" /> is halfway between two whole numbers, the even number is returned; that is, 4.5 is converted to 4, and 5.5 is converted to 6.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than zero or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006BD RID: 1725 RVA: 0x00005E68 File Offset: 0x00004068
		[Token(Token = "0x60006BD")]
		[Address(RVA = "0x2C3A710", Offset = "0x2C39710", VA = "0x182C3A710")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(decimal value)
		{
			return 0UL;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <returns>A 64-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt64.MinValue" /> or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006BE RID: 1726 RVA: 0x00005E80 File Offset: 0x00004080
		[Token(Token = "0x60006BE")]
		[Address(RVA = "0x2C3A5A0", Offset = "0x2C395A0", VA = "0x182C3A5A0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(string value)
		{
			return 0UL;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent 64-bit unsigned integer, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> does not consist of an optional sign followed by a sequence of digits (0 through 9).</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt64.MinValue" /> or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060006BF RID: 1727 RVA: 0x00005E98 File Offset: 0x00004098
		[Token(Token = "0x60006BF")]
		[Address(RVA = "0x2C3A790", Offset = "0x2C39790", VA = "0x182C3A790")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(string value, IFormatProvider provider)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified object to an single-precision floating-point number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement <see cref="T:System.IConvertible" />.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Single.MinValue" /> or greater than <see cref="F:System.Single.MaxValue" />.</exception>
		// Token: 0x060006C0 RID: 1728 RVA: 0x00005EB0 File Offset: 0x000040B0
		[Token(Token = "0x60006C0")]
		[Address(RVA = "0x2C38F40", Offset = "0x2C37F40", VA = "0x182C38F40")]
		public static float ToSingle(object value, IFormatProvider provider)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>An 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C1 RID: 1729 RVA: 0x00005EC8 File Offset: 0x000040C8
		[Token(Token = "0x60006C1")]
		[Address(RVA = "0x2C38EA0", Offset = "0x2C37EA0", VA = "0x182C38EA0")]
		[CLSCompliant(false)]
		public static float ToSingle(sbyte value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C2 RID: 1730 RVA: 0x00005EE0 File Offset: 0x000040E0
		[Token(Token = "0x60006C2")]
		[Address(RVA = "0x2C38DD0", Offset = "0x2C37DD0", VA = "0x182C38DD0")]
		public static float ToSingle(byte value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C3 RID: 1731 RVA: 0x00005EF8 File Offset: 0x000040F8
		[Token(Token = "0x60006C3")]
		[Address(RVA = "0x2C38E60", Offset = "0x2C37E60", VA = "0x182C38E60")]
		public static float ToSingle(short value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C4 RID: 1732 RVA: 0x00005F10 File Offset: 0x00004110
		[Token(Token = "0x60006C4")]
		[Address(RVA = "0x2C39010", Offset = "0x2C38010", VA = "0x182C39010")]
		[CLSCompliant(false)]
		public static float ToSingle(ushort value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C5 RID: 1733 RVA: 0x00005F28 File Offset: 0x00004128
		[Token(Token = "0x60006C5")]
		[Address(RVA = "0x2C38E70", Offset = "0x2C37E70", VA = "0x182C38E70")]
		public static float ToSingle(int value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C6 RID: 1734 RVA: 0x00005F40 File Offset: 0x00004140
		[Token(Token = "0x60006C6")]
		[Address(RVA = "0x2C38EB0", Offset = "0x2C37EB0", VA = "0x182C38EB0")]
		[CLSCompliant(false)]
		public static float ToSingle(uint value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C7 RID: 1735 RVA: 0x00005F58 File Offset: 0x00004158
		[Token(Token = "0x60006C7")]
		[Address(RVA = "0x2C38E50", Offset = "0x2C37E50", VA = "0x182C38E50")]
		public static float ToSingle(long value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006C8 RID: 1736 RVA: 0x00005F70 File Offset: 0x00004170
		[Token(Token = "0x60006C8")]
		[Address(RVA = "0x2C38FF0", Offset = "0x2C37FF0", VA = "0x182C38FF0")]
		[CLSCompliant(false)]
		public static float ToSingle(ulong value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.  
		///  <paramref name="value" /> is rounded using rounding to nearest. For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36.</returns>
		// Token: 0x060006C9 RID: 1737 RVA: 0x00005F88 File Offset: 0x00004188
		[Token(Token = "0x60006C9")]
		[Address(RVA = "0x2C38F30", Offset = "0x2C37F30", VA = "0x182C38F30")]
		public static float ToSingle(double value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to <paramref name="value" />.  
		///  <paramref name="value" /> is rounded using rounding to nearest. For example, when rounded to two decimals, the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36.</returns>
		// Token: 0x060006CA RID: 1738 RVA: 0x00005FA0 File Offset: 0x000041A0
		[Token(Token = "0x60006CA")]
		[Address(RVA = "0x2C38ED0", Offset = "0x2C37ED0", VA = "0x182C38ED0")]
		public static float ToSingle(decimal value)
		{
			return 0f;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent single-precision floating-point number.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <returns>A single-precision floating-point number that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a number in a valid format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Single.MinValue" /> or greater than <see cref="F:System.Single.MaxValue" />.</exception>
		// Token: 0x060006CB RID: 1739 RVA: 0x00005FB8 File Offset: 0x000041B8
		[Token(Token = "0x60006CB")]
		[Address(RVA = "0x2C38DE0", Offset = "0x2C37DE0", VA = "0x182C38DE0")]
		public static float ToSingle(string value)
		{
			return 0f;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent single-precision floating-point number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A single-precision floating-point number that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a number in a valid format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Single.MinValue" /> or greater than <see cref="F:System.Single.MaxValue" />.</exception>
		// Token: 0x060006CC RID: 1740 RVA: 0x00005FD0 File Offset: 0x000041D0
		[Token(Token = "0x60006CC")]
		[Address(RVA = "0x2C38E80", Offset = "0x2C37E80", VA = "0x182C38E80")]
		public static float ToSingle(string value, IFormatProvider provider)
		{
			return 0f;
		}

		/// <summary>Converts the specified Boolean value to the equivalent single-precision floating-point number.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x060006CD RID: 1741 RVA: 0x00005FE8 File Offset: 0x000041E8
		[Token(Token = "0x60006CD")]
		[Address(RVA = "0x2C38EC0", Offset = "0x2C37EC0", VA = "0x182C38EC0")]
		public static float ToSingle(bool value)
		{
			return 0f;
		}

		/// <summary>Converts the value of the specified object to a double-precision floating-point number.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface, or <see langword="null" />.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format for a <see cref="T:System.Double" /> type.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Double.MinValue" /> or greater than <see cref="F:System.Double.MaxValue" />.</exception>
		// Token: 0x060006CE RID: 1742 RVA: 0x00006000 File Offset: 0x00004200
		[Token(Token = "0x60006CE")]
		[Address(RVA = "0x2C371D0", Offset = "0x2C361D0", VA = "0x182C371D0")]
		public static double ToDouble(object value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified object to an double-precision floating-point number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />, or zero if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format for a <see cref="T:System.Double" /> type.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Double.MinValue" /> or greater than <see cref="F:System.Double.MaxValue" />.</exception>
		// Token: 0x060006CF RID: 1743 RVA: 0x00006018 File Offset: 0x00004218
		[Token(Token = "0x60006CF")]
		[Address(RVA = "0x2C37020", Offset = "0x2C36020", VA = "0x182C37020")]
		public static double ToDouble(object value, IFormatProvider provider)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>The 8-bit signed integer that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D0 RID: 1744 RVA: 0x00006030 File Offset: 0x00004230
		[Token(Token = "0x60006D0")]
		[Address(RVA = "0x2C370F0", Offset = "0x2C360F0", VA = "0x182C370F0")]
		[CLSCompliant(false)]
		public static double ToDouble(sbyte value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>The double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D1 RID: 1745 RVA: 0x00006048 File Offset: 0x00004248
		[Token(Token = "0x60006D1")]
		[Address(RVA = "0x2C372F0", Offset = "0x2C362F0", VA = "0x182C372F0")]
		public static double ToDouble(byte value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A double-precision floating-point number equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D2 RID: 1746 RVA: 0x00006060 File Offset: 0x00004260
		[Token(Token = "0x60006D2")]
		[Address(RVA = "0x2C371B0", Offset = "0x2C361B0", VA = "0x182C371B0")]
		public static double ToDouble(short value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to the equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D3 RID: 1747 RVA: 0x00006078 File Offset: 0x00004278
		[Token(Token = "0x60006D3")]
		[Address(RVA = "0x2C37100", Offset = "0x2C36100", VA = "0x182C37100")]
		[CLSCompliant(false)]
		public static double ToDouble(ushort value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D4 RID: 1748 RVA: 0x00006090 File Offset: 0x00004290
		[Token(Token = "0x60006D4")]
		[Address(RVA = "0x2C37270", Offset = "0x2C36270", VA = "0x182C37270")]
		public static double ToDouble(int value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D5 RID: 1749 RVA: 0x000060A8 File Offset: 0x000042A8
		[Token(Token = "0x60006D5")]
		[Address(RVA = "0x2C371C0", Offset = "0x2C361C0", VA = "0x182C371C0")]
		[CLSCompliant(false)]
		public static double ToDouble(uint value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D6 RID: 1750 RVA: 0x000060C0 File Offset: 0x000042C0
		[Token(Token = "0x60006D6")]
		[Address(RVA = "0x2C37110", Offset = "0x2C36110", VA = "0x182C37110")]
		public static double ToDouble(long value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D7 RID: 1751 RVA: 0x000060D8 File Offset: 0x000042D8
		[Token(Token = "0x60006D7")]
		[Address(RVA = "0x2C370D0", Offset = "0x2C360D0", VA = "0x182C370D0")]
		[CLSCompliant(false)]
		public static double ToDouble(ulong value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The single-precision floating-point number.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D8 RID: 1752 RVA: 0x000060F0 File Offset: 0x000042F0
		[Token(Token = "0x60006D8")]
		[Address(RVA = "0x2C37120", Offset = "0x2C36120", VA = "0x182C37120")]
		public static double ToDouble(float value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified decimal number to an equivalent double-precision floating-point number.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>A double-precision floating-point number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006D9 RID: 1753 RVA: 0x00006108 File Offset: 0x00004308
		[Token(Token = "0x60006D9")]
		[Address(RVA = "0x2C37280", Offset = "0x2C36280", VA = "0x182C37280")]
		public static double ToDouble(decimal value)
		{
			return 0.0;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent double-precision floating-point number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A double-precision floating-point number that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a number in a valid format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Double.MinValue" /> or greater than <see cref="F:System.Double.MaxValue" />.</exception>
		// Token: 0x060006DA RID: 1754 RVA: 0x00006120 File Offset: 0x00004320
		[Token(Token = "0x60006DA")]
		[Address(RVA = "0x2C37130", Offset = "0x2C36130", VA = "0x182C37130")]
		public static double ToDouble(string value, IFormatProvider provider)
		{
			return 0.0;
		}

		/// <summary>Converts the specified Boolean value to the equivalent double-precision floating-point number.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x060006DB RID: 1755 RVA: 0x00006138 File Offset: 0x00004338
		[Token(Token = "0x60006DB")]
		[Address(RVA = "0x2C372E0", Offset = "0x2C362E0", VA = "0x182C372E0")]
		public static double ToDouble(bool value)
		{
			return 0.0;
		}

		/// <summary>Converts the value of the specified object to an equivalent decimal number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not in an appropriate format for a <see cref="T:System.Decimal" /> type.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060006DC RID: 1756 RVA: 0x00006150 File Offset: 0x00004350
		[Token(Token = "0x60006DC")]
		[Address(RVA = "0x2C36C70", Offset = "0x2C35C70", VA = "0x182C36C70")]
		public static decimal ToDecimal(object value, IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 8-bit signed integer to the equivalent decimal number.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006DD RID: 1757 RVA: 0x00006168 File Offset: 0x00004368
		[Token(Token = "0x60006DD")]
		[Address(RVA = "0x2C36A50", Offset = "0x2C35A50", VA = "0x182C36A50")]
		[CLSCompliant(false)]
		public static decimal ToDecimal(sbyte value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 8-bit unsigned integer to the equivalent decimal number.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>The decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006DE RID: 1758 RVA: 0x00006180 File Offset: 0x00004380
		[Token(Token = "0x60006DE")]
		[Address(RVA = "0x2C36970", Offset = "0x2C35970", VA = "0x182C36970")]
		public static decimal ToDecimal(byte value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 16-bit signed integer to an equivalent decimal number.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006DF RID: 1759 RVA: 0x00006198 File Offset: 0x00004398
		[Token(Token = "0x60006DF")]
		[Address(RVA = "0x2C36DF0", Offset = "0x2C35DF0", VA = "0x182C36DF0")]
		public static decimal ToDecimal(short value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 16-bit unsigned integer to an equivalent decimal number.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>The decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006E0 RID: 1760 RVA: 0x000061B0 File Offset: 0x000043B0
		[Token(Token = "0x60006E0")]
		[Address(RVA = "0x2C36FB0", Offset = "0x2C35FB0", VA = "0x182C36FB0")]
		[CLSCompliant(false)]
		public static decimal ToDecimal(ushort value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to an equivalent decimal number.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006E1 RID: 1761 RVA: 0x000061C8 File Offset: 0x000043C8
		[Token(Token = "0x60006E1")]
		[Address(RVA = "0x2C36AC0", Offset = "0x2C35AC0", VA = "0x182C36AC0")]
		public static decimal ToDecimal(int value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 32-bit unsigned integer to an equivalent decimal number.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006E2 RID: 1762 RVA: 0x000061E0 File Offset: 0x000043E0
		[Token(Token = "0x60006E2")]
		[Address(RVA = "0x2C369E0", Offset = "0x2C359E0", VA = "0x182C369E0")]
		[CLSCompliant(false)]
		public static decimal ToDecimal(uint value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to an equivalent decimal number.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006E3 RID: 1763 RVA: 0x000061F8 File Offset: 0x000043F8
		[Token(Token = "0x60006E3")]
		[Address(RVA = "0x2C36E60", Offset = "0x2C35E60", VA = "0x182C36E60")]
		public static decimal ToDecimal(long value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to an equivalent decimal number.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		// Token: 0x060006E4 RID: 1764 RVA: 0x00006210 File Offset: 0x00004410
		[Token(Token = "0x60006E4")]
		[Address(RVA = "0x2C36C00", Offset = "0x2C35C00", VA = "0x182C36C00")]
		[CLSCompliant(false)]
		public static decimal ToDecimal(ulong value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to the equivalent decimal number.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Decimal.MaxValue" /> or less than <see cref="F:System.Decimal.MinValue" />.</exception>
		// Token: 0x060006E5 RID: 1765 RVA: 0x00006228 File Offset: 0x00004428
		[Token(Token = "0x60006E5")]
		[Address(RVA = "0x2C36900", Offset = "0x2C35900", VA = "0x182C36900")]
		public static decimal ToDecimal(float value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to an equivalent decimal number.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>A decimal number that is equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.Decimal.MaxValue" /> or less than <see cref="F:System.Decimal.MinValue" />.</exception>
		// Token: 0x060006E6 RID: 1766 RVA: 0x00006240 File Offset: 0x00004440
		[Token(Token = "0x60006E6")]
		[Address(RVA = "0x2C36F40", Offset = "0x2C35F40", VA = "0x182C36F40")]
		public static decimal ToDecimal(double value)
		{
			return 0m;
		}

		/// <summary>Converts the specified string representation of a number to an equivalent decimal number, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains a number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>A decimal number that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a number in a valid format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> represents a number that is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060006E7 RID: 1767 RVA: 0x00006258 File Offset: 0x00004458
		[Token(Token = "0x60006E7")]
		[Address(RVA = "0x2C36B30", Offset = "0x2C35B30", VA = "0x182C36B30")]
		public static decimal ToDecimal(string value, IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>Returns the specified decimal number; no actual conversion is performed.</summary>
		/// <param name="value">A decimal number.</param>
		/// <returns>
		///   <paramref name="value" /> is returned unchanged.</returns>
		// Token: 0x060006E8 RID: 1768 RVA: 0x00006270 File Offset: 0x00004470
		[Token(Token = "0x60006E8")]
		[Address(RVA = "0x814AC0", Offset = "0x813AC0", VA = "0x180814AC0")]
		public static decimal ToDecimal(decimal value)
		{
			return 0m;
		}

		/// <summary>Converts the specified Boolean value to the equivalent decimal number.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The number 1 if <paramref name="value" /> is <see langword="true" />; otherwise, 0.</returns>
		// Token: 0x060006E9 RID: 1769 RVA: 0x00006288 File Offset: 0x00004488
		[Token(Token = "0x60006E9")]
		[Address(RVA = "0x2C36ED0", Offset = "0x2C35ED0", VA = "0x182C36ED0")]
		public static decimal ToDecimal(bool value)
		{
			return 0m;
		}

		/// <summary>Converts the value of the specified object to a <see cref="T:System.DateTime" /> object, using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that implements the <see cref="T:System.IConvertible" /> interface.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The date and time equivalent of the value of <paramref name="value" />, or the date and time equivalent of <see cref="F:System.DateTime.MinValue" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a valid date and time value.</exception>
		/// <exception cref="T:System.InvalidCastException">
		///   <paramref name="value" /> does not implement the <see cref="T:System.IConvertible" /> interface.  
		/// -or-  
		/// The conversion is not supported.</exception>
		// Token: 0x060006EA RID: 1770 RVA: 0x000062A0 File Offset: 0x000044A0
		[Token(Token = "0x60006EA")]
		[Address(RVA = "0x2C36790", Offset = "0x2C35790", VA = "0x182C36790")]
		public static DateTime ToDateTime(object value, IFormatProvider provider)
		{
			return default(DateTime);
		}

		/// <summary>Converts the specified string representation of a date and time to an equivalent date and time value.</summary>
		/// <param name="value">The string representation of a date and time.</param>
		/// <returns>The date and time equivalent of the value of <paramref name="value" />, or the date and time equivalent of <see cref="F:System.DateTime.MinValue" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a properly formatted date and time string.</exception>
		// Token: 0x060006EB RID: 1771 RVA: 0x000062B8 File Offset: 0x000044B8
		[Token(Token = "0x60006EB")]
		[Address(RVA = "0x2C366E0", Offset = "0x2C356E0", VA = "0x182C366E0")]
		public static DateTime ToDateTime(string value)
		{
			return default(DateTime);
		}

		/// <summary>Converts the specified string representation of a number to an equivalent date and time, using the specified culture-specific formatting information.</summary>
		/// <param name="value">A string that contains a date and time to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The date and time equivalent of the value of <paramref name="value" />, or the date and time equivalent of <see cref="F:System.DateTime.MinValue" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> is not a properly formatted date and time string.</exception>
		// Token: 0x060006EC RID: 1772 RVA: 0x000062D0 File Offset: 0x000044D0
		[Token(Token = "0x60006EC")]
		[Address(RVA = "0x2C36870", Offset = "0x2C35870", VA = "0x182C36870")]
		public static DateTime ToDateTime(string value, IFormatProvider provider)
		{
			return default(DateTime);
		}

		/// <summary>Converts the value of the specified object to its equivalent string representation.</summary>
		/// <param name="value">An object that supplies the value to convert, or <see langword="null" />.</param>
		/// <returns>The string representation of <paramref name="value" />, or <see cref="F:System.String.Empty" /> if <paramref name="value" /> is <see langword="null" />.</returns>
		// Token: 0x060006ED RID: 1773 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006ED")]
		[Address(RVA = "0x2C392F0", Offset = "0x2C382F0", VA = "0x182C392F0")]
		public static string ToString(object value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified object to its equivalent string representation using the specified culture-specific formatting information.</summary>
		/// <param name="value">An object that supplies the value to convert, or <see langword="null" />.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />, or <see cref="F:System.String.Empty" /> if <paramref name="value" /> is an object whose value is <see langword="null" />. If <paramref name="value" /> is <see langword="null" />, the method returns <see langword="null" />.</returns>
		// Token: 0x060006EE RID: 1774 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006EE")]
		[Address(RVA = "0x2C39060", Offset = "0x2C38060", VA = "0x182C39060")]
		public static string ToString(object value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the specified Boolean value to its equivalent string representation.</summary>
		/// <param name="value">The Boolean value to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006EF RID: 1775 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006EF")]
		[Address(RVA = "0x2C392B0", Offset = "0x2C382B0", VA = "0x182C392B0")]
		public static string ToString(bool value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified Unicode character to its equivalent string representation.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F0 RID: 1776 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F0")]
		[Address(RVA = "0x2C391D0", Offset = "0x2C381D0", VA = "0x182C391D0")]
		public static string ToString(char value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified Unicode character to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information. This parameter is ignored.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F1 RID: 1777 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F1")]
		[Address(RVA = "0x2C391B0", Offset = "0x2C381B0", VA = "0x182C391B0")]
		public static string ToString(char value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to its equivalent string representation.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F2 RID: 1778 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F2")]
		[Address(RVA = "0x2C394F0", Offset = "0x2C384F0", VA = "0x182C394F0")]
		public static string ToString(int value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 32-bit signed integer to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F3 RID: 1779 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F3")]
		[Address(RVA = "0x2C39040", Offset = "0x2C38040", VA = "0x182C39040")]
		public static string ToString(int value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to its equivalent string representation.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F4 RID: 1780 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F4")]
		[Address(RVA = "0x2C39250", Offset = "0x2C38250", VA = "0x182C39250")]
		public static string ToString(long value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 64-bit signed integer to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F5 RID: 1781 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F5")]
		[Address(RVA = "0x2C39680", Offset = "0x2C38680", VA = "0x182C39680")]
		public static string ToString(long value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to its equivalent string representation.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F6 RID: 1782 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F6")]
		[Address(RVA = "0x2C39570", Offset = "0x2C38570", VA = "0x182C39570")]
		[CLSCompliant(false)]
		public static string ToString(ulong value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified 64-bit unsigned integer to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F7 RID: 1783 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F7")]
		[Address(RVA = "0x2C392D0", Offset = "0x2C382D0", VA = "0x182C392D0")]
		[CLSCompliant(false)]
		public static string ToString(ulong value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified single-precision floating-point number to its equivalent string representation.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F8 RID: 1784 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F8")]
		[Address(RVA = "0x2C396A0", Offset = "0x2C386A0", VA = "0x182C396A0")]
		public static string ToString(float value)
		{
			return null;
		}

		/// <summary>Converts the value of the specified double-precision floating-point number to its equivalent string representation.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006F9 RID: 1785 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006F9")]
		[Address(RVA = "0x2C39020", Offset = "0x2C38020", VA = "0x182C39020")]
		public static string ToString(double value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified decimal number to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006FA RID: 1786 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006FA")]
		[Address(RVA = "0x2C39550", Offset = "0x2C38550", VA = "0x182C39550")]
		public static string ToString(decimal value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.DateTime" /> to its equivalent string representation, using the specified culture-specific formatting information.</summary>
		/// <param name="value">The date and time value to convert.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of <paramref name="value" />.</returns>
		// Token: 0x060006FB RID: 1787 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60006FB")]
		[Address(RVA = "0x2C39230", Offset = "0x2C38230", VA = "0x182C39230")]
		public static string ToString(DateTime value, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>An 8-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a base 10 unsigned number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x060006FC RID: 1788 RVA: 0x000062E8 File Offset: 0x000044E8
		[Token(Token = "0x60006FC")]
		[Address(RVA = "0x2C35AF0", Offset = "0x2C34AF0", VA = "0x182C35AF0")]
		public static byte ToByte(string value, int fromBase)
		{
			return 0;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 8-bit signed integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>An 8-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.SByte.MinValue" /> or greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x060006FD RID: 1789 RVA: 0x00006300 File Offset: 0x00004500
		[Token(Token = "0x60006FD")]
		[Address(RVA = "0x2C38580", Offset = "0x2C37580", VA = "0x182C38580")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(string value, int fromBase)
		{
			return 0;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 16-bit signed integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 16-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.Int16.MinValue" /> or greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x060006FE RID: 1790 RVA: 0x00006318 File Offset: 0x00004518
		[Token(Token = "0x60006FE")]
		[Address(RVA = "0x2C378F0", Offset = "0x2C368F0", VA = "0x182C378F0")]
		public static short ToInt16(string value, int fromBase)
		{
			return 0;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 16-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt16.MinValue" /> or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x060006FF RID: 1791 RVA: 0x00006330 File Offset: 0x00004530
		[Token(Token = "0x60006FF")]
		[Address(RVA = "0x2C39DD0", Offset = "0x2C38DD0", VA = "0x182C39DD0")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(string value, int fromBase)
		{
			return 0;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 32-bit signed integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 32-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x06000700 RID: 1792 RVA: 0x00006348 File Offset: 0x00004548
		[Token(Token = "0x6000700")]
		[Address(RVA = "0x2C37DA0", Offset = "0x2C36DA0", VA = "0x182C37DA0")]
		public static int ToInt32(string value, int fromBase)
		{
			return 0;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 32-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 32-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt32.MinValue" /> or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x06000701 RID: 1793 RVA: 0x00006360 File Offset: 0x00004560
		[Token(Token = "0x6000701")]
		[Address(RVA = "0x2C39F30", Offset = "0x2C38F30", VA = "0x182C39F30")]
		[CLSCompliant(false)]
		public static uint ToUInt32(string value, int fromBase)
		{
			return 0U;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 64-bit signed integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 64-bit signed integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 signed number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x06000702 RID: 1794 RVA: 0x00006378 File Offset: 0x00004578
		[Token(Token = "0x6000702")]
		[Address(RVA = "0x2C383A0", Offset = "0x2C373A0", VA = "0x182C383A0")]
		public static long ToInt64(string value, int fromBase)
		{
			return 0L;
		}

		/// <summary>Converts the string representation of a number in a specified base to an equivalent 64-bit unsigned integer.</summary>
		/// <param name="value">A string that contains the number to convert.</param>
		/// <param name="fromBase">The base of the number in <paramref name="value" />, which must be 2, 8, 10, or 16.</param>
		/// <returns>A 64-bit unsigned integer that is equivalent to the number in <paramref name="value" />, or 0 (zero) if <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="fromBase" /> is not 2, 8, 10, or 16.  
		/// -or-  
		/// <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="value" /> is <see cref="F:System.String.Empty" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="value" /> contains a character that is not a valid digit in the base specified by <paramref name="fromBase" />. The exception message indicates that there are no digits to convert if the first character in <paramref name="value" /> is invalid; otherwise, the message indicates that <paramref name="value" /> contains invalid trailing characters.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" />, which represents a non-base 10 unsigned number, is prefixed with a negative sign.  
		/// -or-  
		/// <paramref name="value" /> represents a number that is less than <see cref="F:System.UInt64.MinValue" /> or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x06000703 RID: 1795 RVA: 0x00006390 File Offset: 0x00004590
		[Token(Token = "0x6000703")]
		[Address(RVA = "0x2C3A7B0", Offset = "0x2C397B0", VA = "0x182C3A7B0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(string value, int fromBase)
		{
			return 0UL;
		}

		/// <summary>Converts the value of an 8-bit unsigned integer to its equivalent string representation in a specified base.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <param name="toBase">The base of the return value, which must be 2, 8, 10, or 16.</param>
		/// <returns>The string representation of <paramref name="value" /> in base <paramref name="toBase" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="toBase" /> is not 2, 8, 10, or 16.</exception>
		// Token: 0x06000704 RID: 1796 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000704")]
		[Address(RVA = "0x2C395D0", Offset = "0x2C385D0", VA = "0x182C395D0")]
		public static string ToString(byte value, int toBase)
		{
			return null;
		}

		/// <summary>Converts the value of a 32-bit signed integer to its equivalent string representation in a specified base.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <param name="toBase">The base of the return value, which must be 2, 8, 10, or 16.</param>
		/// <returns>The string representation of <paramref name="value" /> in base <paramref name="toBase" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="toBase" /> is not 2, 8, 10, or 16.</exception>
		// Token: 0x06000705 RID: 1797 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000705")]
		[Address(RVA = "0x2C39700", Offset = "0x2C38700", VA = "0x182C39700")]
		public static string ToString(int value, int toBase)
		{
			return null;
		}

		/// <summary>Converts the value of a 64-bit signed integer to its equivalent string representation in a specified base.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <param name="toBase">The base of the return value, which must be 2, 8, 10, or 16.</param>
		/// <returns>The string representation of <paramref name="value" /> in base <paramref name="toBase" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="toBase" /> is not 2, 8, 10, or 16.</exception>
		// Token: 0x06000706 RID: 1798 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000706")]
		[Address(RVA = "0x2C39450", Offset = "0x2C38450", VA = "0x182C39450")]
		public static string ToString(long value, int toBase)
		{
			return null;
		}

		/// <summary>Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits.</summary>
		/// <param name="inArray">An array of 8-bit unsigned integers.</param>
		/// <returns>The string representation, in base 64, of the contents of <paramref name="inArray" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> is <see langword="null" />.</exception>
		// Token: 0x06000707 RID: 1799 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000707")]
		[Address(RVA = "0x2C35480", Offset = "0x2C34480", VA = "0x182C35480")]
		public static string ToBase64String(byte[] inArray)
		{
			return null;
		}

		/// <summary>Converts an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. A parameter specifies whether to insert line breaks in the return value.</summary>
		/// <param name="inArray">An array of 8-bit unsigned integers.</param>
		/// <param name="options">
		///   <see cref="F:System.Base64FormattingOptions.InsertLineBreaks" /> to insert a line break every 76 characters, or <see cref="F:System.Base64FormattingOptions.None" /> to not insert line breaks.</param>
		/// <returns>The string representation in base 64 of the elements in <paramref name="inArray" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not a valid <see cref="T:System.Base64FormattingOptions" /> value.</exception>
		// Token: 0x06000708 RID: 1800 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000708")]
		[Address(RVA = "0x2C353D0", Offset = "0x2C343D0", VA = "0x182C353D0")]
		[ComVisible(false)]
		public static string ToBase64String(byte[] inArray, Base64FormattingOptions options)
		{
			return null;
		}

		/// <summary>Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameters specify the subset as an offset in the input array, and the number of elements in the array to convert.</summary>
		/// <param name="inArray">An array of 8-bit unsigned integers.</param>
		/// <param name="offset">An offset in <paramref name="inArray" />.</param>
		/// <param name="length">The number of elements of <paramref name="inArray" /> to convert.</param>
		/// <returns>The string representation in base 64 of <paramref name="length" /> elements of <paramref name="inArray" />, starting at position <paramref name="offset" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offset" /> or <paramref name="length" /> is negative.  
		/// -or-  
		/// <paramref name="offset" /> plus <paramref name="length" /> is greater than the length of <paramref name="inArray" />.</exception>
		// Token: 0x06000709 RID: 1801 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000709")]
		[Address(RVA = "0x2C35350", Offset = "0x2C34350", VA = "0x182C35350")]
		public static string ToBase64String(byte[] inArray, int offset, int length)
		{
			return null;
		}

		/// <summary>Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.</summary>
		/// <param name="inArray">An array of 8-bit unsigned integers.</param>
		/// <param name="offset">An offset in <paramref name="inArray" />.</param>
		/// <param name="length">The number of elements of <paramref name="inArray" /> to convert.</param>
		/// <param name="options">
		///   <see cref="F:System.Base64FormattingOptions.InsertLineBreaks" /> to insert a line break every 76 characters, or <see cref="F:System.Base64FormattingOptions.None" /> to not insert line breaks.</param>
		/// <returns>The string representation in base 64 of <paramref name="length" /> elements of <paramref name="inArray" />, starting at position <paramref name="offset" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offset" /> or <paramref name="length" /> is negative.  
		/// -or-  
		/// <paramref name="offset" /> plus <paramref name="length" /> is greater than the length of <paramref name="inArray" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not a valid <see cref="T:System.Base64FormattingOptions" /> value.</exception>
		// Token: 0x0600070A RID: 1802 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600070A")]
		[Address(RVA = "0x2C35060", Offset = "0x2C34060", VA = "0x182C35060")]
		[ComVisible(false)]
		public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
		{
			return null;
		}

		/// <summary>Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. Parameters specify the subsets as offsets in the input and output arrays, and the number of elements in the input array to convert.</summary>
		/// <param name="inArray">An input array of 8-bit unsigned integers.</param>
		/// <param name="offsetIn">A position within <paramref name="inArray" />.</param>
		/// <param name="length">The number of elements of <paramref name="inArray" /> to convert.</param>
		/// <param name="outArray">An output array of Unicode characters.</param>
		/// <param name="offsetOut">A position within <paramref name="outArray" />.</param>
		/// <returns>A 32-bit signed integer containing the number of bytes in <paramref name="outArray" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> or <paramref name="outArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offsetIn" />, <paramref name="offsetOut" />, or <paramref name="length" /> is negative.  
		/// -or-  
		/// <paramref name="offsetIn" /> plus <paramref name="length" /> is greater than the length of <paramref name="inArray" />.  
		/// -or-  
		/// <paramref name="offsetOut" /> plus the number of elements to return is greater than the length of <paramref name="outArray" />.</exception>
		// Token: 0x0600070B RID: 1803 RVA: 0x000063A8 File Offset: 0x000045A8
		[Token(Token = "0x600070B")]
		[Address(RVA = "0x2C34C00", Offset = "0x2C33C00", VA = "0x182C34C00")]
		public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut)
		{
			return 0;
		}

		/// <summary>Converts a subset of an 8-bit unsigned integer array to an equivalent subset of a Unicode character array encoded with base-64 digits. Parameters specify the subsets as offsets in the input and output arrays, the number of elements in the input array to convert, and whether line breaks are inserted in the output array.</summary>
		/// <param name="inArray">An input array of 8-bit unsigned integers.</param>
		/// <param name="offsetIn">A position within <paramref name="inArray" />.</param>
		/// <param name="length">The number of elements of <paramref name="inArray" /> to convert.</param>
		/// <param name="outArray">An output array of Unicode characters.</param>
		/// <param name="offsetOut">A position within <paramref name="outArray" />.</param>
		/// <param name="options">
		///   <see cref="F:System.Base64FormattingOptions.InsertLineBreaks" /> to insert a line break every 76 characters, or <see cref="F:System.Base64FormattingOptions.None" /> to not insert line breaks.</param>
		/// <returns>A 32-bit signed integer containing the number of bytes in <paramref name="outArray" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> or <paramref name="outArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offsetIn" />, <paramref name="offsetOut" />, or <paramref name="length" /> is negative.  
		/// -or-  
		/// <paramref name="offsetIn" /> plus <paramref name="length" /> is greater than the length of <paramref name="inArray" />.  
		/// -or-  
		/// <paramref name="offsetOut" /> plus the number of elements to return is greater than the length of <paramref name="outArray" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="options" /> is not a valid <see cref="T:System.Base64FormattingOptions" /> value.</exception>
		// Token: 0x0600070C RID: 1804 RVA: 0x000063C0 File Offset: 0x000045C0
		[Token(Token = "0x600070C")]
		[Address(RVA = "0x2C34C90", Offset = "0x2C33C90", VA = "0x182C34C90")]
		[ComVisible(false)]
		public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut, Base64FormattingOptions options)
		{
			return 0;
		}

		// Token: 0x0600070D RID: 1805 RVA: 0x000063D8 File Offset: 0x000045D8
		[Token(Token = "0x600070D")]
		[Address(RVA = "0x2C33100", Offset = "0x2C32100", VA = "0x182C33100")]
		private unsafe static int ConvertToBase64Array(char* outChars, byte* inData, int offset, int length, bool insertLineBreaks)
		{
			return 0;
		}

		// Token: 0x0600070E RID: 1806 RVA: 0x000063F0 File Offset: 0x000045F0
		[Token(Token = "0x600070E")]
		[Address(RVA = "0x2C35520", Offset = "0x2C34520", VA = "0x182C35520")]
		private static int ToBase64_CalculateAndValidateOutputLength(int inputLength, bool insertLineBreaks)
		{
			return 0;
		}

		/// <summary>Converts the specified string, which encodes binary data as base-64 digits, to an equivalent 8-bit unsigned integer array.</summary>
		/// <param name="s">The string to convert.</param>
		/// <returns>An array of 8-bit unsigned integers that is equivalent to <paramref name="s" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">The length of <paramref name="s" />, ignoring white-space characters, is not zero or a multiple of 4.  
		///  -or-  
		///  The format of <paramref name="s" /> is invalid. <paramref name="s" /> contains a non-base-64 character, more than two padding characters, or a non-white space-character among the padding characters.</exception>
		// Token: 0x0600070F RID: 1807 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600070F")]
		[Address(RVA = "0x2C34700", Offset = "0x2C33700", VA = "0x182C34700")]
		public static byte[] FromBase64String(string s)
		{
			return null;
		}

		/// <summary>Converts a subset of a Unicode character array, which encodes binary data as base-64 digits, to an equivalent 8-bit unsigned integer array. Parameters specify the subset in the input array and the number of elements to convert.</summary>
		/// <param name="inArray">A Unicode character array.</param>
		/// <param name="offset">A position within <paramref name="inArray" />.</param>
		/// <param name="length">The number of elements in <paramref name="inArray" /> to convert.</param>
		/// <returns>An array of 8-bit unsigned integers equivalent to <paramref name="length" /> elements at position <paramref name="offset" /> in <paramref name="inArray" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="inArray" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="offset" /> or <paramref name="length" /> is less than 0.  
		/// -or-  
		/// <paramref name="offset" /> plus <paramref name="length" /> indicates a position not within <paramref name="inArray" />.</exception>
		/// <exception cref="T:System.FormatException">The length of <paramref name="inArray" />, ignoring white-space characters, is not zero or a multiple of 4.  
		///  -or-  
		///  The format of <paramref name="inArray" /> is invalid. <paramref name="inArray" /> contains a non-base-64 character, more than two padding characters, or a non-white-space character among the padding characters.</exception>
		// Token: 0x06000710 RID: 1808 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000710")]
		[Address(RVA = "0x2C34380", Offset = "0x2C33380", VA = "0x182C34380")]
		public static byte[] FromBase64CharArray(char[] inArray, int offset, int length)
		{
			return null;
		}

		// Token: 0x06000711 RID: 1809 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000711")]
		[Address(RVA = "0x2C34520", Offset = "0x2C33520", VA = "0x182C34520")]
		private unsafe static byte[] FromBase64CharPtr(char* inputPtr, int inputLength)
		{
			return null;
		}

		// Token: 0x06000712 RID: 1810 RVA: 0x00006408 File Offset: 0x00004608
		[Token(Token = "0x6000712")]
		[Address(RVA = "0x2C34890", Offset = "0x2C33890", VA = "0x182C34890")]
		private unsafe static int FromBase64_Decode(char* startInputPtr, int inputLength, byte* startDestPtr, int destLength)
		{
			return 0;
		}

		// Token: 0x06000713 RID: 1811 RVA: 0x00006420 File Offset: 0x00004620
		[Token(Token = "0x6000713")]
		[Address(RVA = "0x2C347B0", Offset = "0x2C337B0", VA = "0x182C347B0")]
		private unsafe static int FromBase64_ComputeResultLength(char* inputPtr, int inputLength)
		{
			return 0;
		}

		// Token: 0x040002E7 RID: 743
		[Token(Token = "0x40002E7")]
		internal static readonly RuntimeType[] ConvertTypes;

		// Token: 0x040002E8 RID: 744
		[Token(Token = "0x40002E8")]
		private static readonly RuntimeType EnumType;

		// Token: 0x040002E9 RID: 745
		[Token(Token = "0x40002E9")]
		internal static readonly char[] base64Table;

		/// <summary>A constant that represents a database column that is absent of data; that is, database null.</summary>
		// Token: 0x040002EA RID: 746
		[Token(Token = "0x40002EA")]
		public static readonly object DBNull;
	}
}