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

namespace System
{
	/// <summary>Represents a decimal floating-point number.</summary>
	// Token: 0x020000D4 RID: 212
	[Token(Token = "0x20000D4")]
	[ComVisible(true)]
	[Serializable]
	public struct Decimal : IFormattable, IComparable, IConvertible, IDeserializationCallback, IComparable<decimal>, IEquatable<decimal>
	{
		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified 32-bit signed integer.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		// Token: 0x060007AF RID: 1967 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007AF")]
		[Address(RVA = "0x2AA5000", Offset = "0x2AA3E00", VA = "0x182AA5000")]
		public Decimal(int value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified 32-bit unsigned integer.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		// Token: 0x060007B0 RID: 1968 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B0")]
		[Address(RVA = "0x2AA4FF0", Offset = "0x2AA3DF0", VA = "0x182AA4FF0")]
		[CLSCompliant(false)]
		public Decimal(uint value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified 64-bit signed integer.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		// Token: 0x060007B1 RID: 1969 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B1")]
		[Address(RVA = "0x2AA51D0", Offset = "0x2AA3FD0", VA = "0x182AA51D0")]
		public Decimal(long value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified 64-bit unsigned integer.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		// Token: 0x060007B2 RID: 1970 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B2")]
		[Address(RVA = "0x2AA4FE0", Offset = "0x2AA3DE0", VA = "0x182AA4FE0")]
		[CLSCompliant(false)]
		public Decimal(ulong value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified single-precision floating-point number.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		/// <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" />.  
		/// -or-  
		/// <paramref name="value" /> is <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.PositiveInfinity" />, or <see cref="F:System.Single.NegativeInfinity" />.</exception>
		// Token: 0x060007B3 RID: 1971 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B3")]
		[Address(RVA = "0x2AA51C0", Offset = "0x2AA3FC0", VA = "0x182AA51C0")]
		public Decimal(float value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to the value of the specified double-precision floating-point number.</summary>
		/// <param name="value">The value to represent as a <see cref="T:System.Decimal" />.</param>
		/// <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" />.  
		/// -or-  
		/// <paramref name="value" /> is <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.PositiveInfinity" />, or <see cref="F:System.Double.NegativeInfinity" />.</exception>
		// Token: 0x060007B4 RID: 1972 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B4")]
		[Address(RVA = "0x2AA5030", Offset = "0x2AA3E30", VA = "0x182AA5030")]
		public Decimal(double value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> to a decimal value represented in binary and contained in a specified array.</summary>
		/// <param name="bits">An array of 32-bit signed integers containing a representation of a decimal value.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="bits" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">The length of the <paramref name="bits" /> is not 4.  
		///  -or-  
		///  The representation of the decimal value in <paramref name="bits" /> is not valid.</exception>
		// Token: 0x060007B5 RID: 1973 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B5")]
		[Address(RVA = "0x2AA4EC0", Offset = "0x2AA3CC0", VA = "0x182AA4EC0")]
		public Decimal(int[] bits)
		{
		}

		// Token: 0x060007B6 RID: 1974 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B6")]
		[Address(RVA = "0x2AA36E0", Offset = "0x2AA24E0", VA = "0x182AA36E0")]
		private void SetBits(int[] bits)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.Decimal" /> from parameters specifying the instance's constituent parts.</summary>
		/// <param name="lo">The low 32 bits of a 96-bit integer.</param>
		/// <param name="mid">The middle 32 bits of a 96-bit integer.</param>
		/// <param name="hi">The high 32 bits of a 96-bit integer.</param>
		/// <param name="isNegative">
		///   <see langword="true" /> to indicate a negative number; <see langword="false" /> to indicate a positive number.</param>
		/// <param name="scale">A power of 10 ranging from 0 to 28.</param>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="scale" /> is greater than 28.</exception>
		// Token: 0x060007B7 RID: 1975 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B7")]
		[Address(RVA = "0x2AA5040", Offset = "0x2AA3E40", VA = "0x182AA5040")]
		public Decimal(int lo, int mid, int hi, bool isNegative, byte scale)
		{
		}

		// Token: 0x060007B8 RID: 1976 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B8")]
		[Address(RVA = "0x2AA34C0", Offset = "0x2AA22C0", VA = "0x182AA34C0")]
		[OnSerializing]
		private void OnSerializing(StreamingContext ctx)
		{
		}

		/// <summary>Runs when the deserialization of an object has been completed.</summary>
		/// <param name="sender">The object that initiated the callback. The functionality for this parameter is not currently implemented.</param>
		/// <exception cref="T:System.Runtime.Serialization.SerializationException">The <see cref="T:System.Decimal" /> object contains invalid or corrupted data.</exception>
		// Token: 0x060007B9 RID: 1977 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007B9")]
		[Address(RVA = "0x2AA3F00", Offset = "0x2AA2D00", VA = "0x182AA3F00", Slot = "23")]
		void IDeserializationCallback.OnDeserialization(object sender)
		{
		}

		// Token: 0x060007BA RID: 1978 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007BA")]
		[Address(RVA = "0x2AA5100", Offset = "0x2AA3F00", VA = "0x182AA5100")]
		private Decimal(int lo, int mid, int hi, int flags)
		{
		}

		// Token: 0x060007BB RID: 1979 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007BB")]
		[Address(RVA = "0x2AA32F0", Offset = "0x2AA20F0", VA = "0x182AA32F0")]
		private static void FCallAddSub(ref decimal d1, ref decimal d2, byte bSign)
		{
		}

		// Token: 0x060007BC RID: 1980 RVA: 0x00007068 File Offset: 0x00005268
		[Token(Token = "0x60007BC")]
		[Address(RVA = "0x2AA3300", Offset = "0x2AA2100", VA = "0x182AA3300")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		private static int FCallCompare(ref decimal d1, ref decimal d2)
		{
			return 0;
		}

		/// <summary>Compares this instance to a specified object and returns a comparison of their relative values.</summary>
		/// <param name="value">The object to compare with this instance, or <see langword="null" />.</param>
		/// <returns>A signed number indicating the relative values of this instance and <paramref name="value" />.  
		///   Return value  
		///
		///   Meaning  
		///
		///   Less than zero  
		///
		///   This instance is less than <paramref name="value" />.  
		///
		///   Zero  
		///
		///   This instance is equal to <paramref name="value" />.  
		///
		///   Greater than zero  
		///
		///   This instance is greater than <paramref name="value" />.  
		///
		///  -or-  
		///
		///  <paramref name="value" /> is <see langword="null" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="value" /> is not a <see cref="T:System.Decimal" />.</exception>
		// Token: 0x060007BD RID: 1981 RVA: 0x00007080 File Offset: 0x00005280
		[Token(Token = "0x60007BD")]
		[Address(RVA = "0x2AA3060", Offset = "0x2AA1E60", VA = "0x182AA3060", Slot = "5")]
		public int CompareTo(object value)
		{
			return 0;
		}

		/// <summary>Compares this instance to a specified <see cref="T:System.Decimal" /> object and returns a comparison of their relative values.</summary>
		/// <param name="value">The object to compare with this instance.</param>
		/// <returns>A signed number indicating the relative values of this instance and <paramref name="value" />.  
		///   Return value  
		///
		///   Meaning  
		///
		///   Less than zero  
		///
		///   This instance is less than <paramref name="value" />.  
		///
		///   Zero  
		///
		///   This instance is equal to <paramref name="value" />.  
		///
		///   Greater than zero  
		///
		///   This instance is greater than <paramref name="value" />.</returns>
		// Token: 0x060007BE RID: 1982 RVA: 0x00007098 File Offset: 0x00005298
		[Token(Token = "0x60007BE")]
		[Address(RVA = "0x2AA3160", Offset = "0x2AA1F60", VA = "0x182AA3160", Slot = "24")]
		public int CompareTo(decimal value)
		{
			return 0;
		}

		// Token: 0x060007BF RID: 1983 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007BF")]
		[Address(RVA = "0x2AA3310", Offset = "0x2AA2110", VA = "0x182AA3310")]
		private static void FCallDivide(ref decimal d1, ref decimal d2)
		{
		}

		/// <summary>Returns a value indicating whether this instance and a specified <see cref="T:System.Object" /> represent the same type and value.</summary>
		/// <param name="value">The object to compare with this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is a <see cref="T:System.Decimal" /> and equal to this instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007C0 RID: 1984 RVA: 0x000070B0 File Offset: 0x000052B0
		[Token(Token = "0x60007C0")]
		[Address(RVA = "0x2AA3230", Offset = "0x2AA2030", VA = "0x182AA3230", Slot = "0")]
		public override bool Equals(object value)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether this instance and a specified <see cref="T:System.Decimal" /> object represent the same value.</summary>
		/// <param name="value">An object to compare to this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value" /> is equal to this instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007C1 RID: 1985 RVA: 0x000070C8 File Offset: 0x000052C8
		[Token(Token = "0x60007C1")]
		[Address(RVA = "0x2AA31C0", Offset = "0x2AA1FC0", VA = "0x182AA31C0", Slot = "25")]
		public bool Equals(decimal value)
		{
			return default(bool);
		}

		/// <summary>Returns the hash code for this instance.</summary>
		/// <returns>A 32-bit signed integer hash code.</returns>
		// Token: 0x060007C2 RID: 1986 RVA: 0x000070E0 File Offset: 0x000052E0
		[Token(Token = "0x60007C2")]
		[Address(RVA = "0x2AA3450", Offset = "0x2AA2250", VA = "0x182AA3450", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		/// <summary>Converts the numeric value of this instance to its equivalent string representation.</summary>
		/// <returns>A string that represents the value of this instance.</returns>
		// Token: 0x060007C3 RID: 1987 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007C3")]
		[Address(RVA = "0x2AA4800", Offset = "0x2AA3600", VA = "0x182AA4800", Slot = "3")]
		public override string ToString()
		{
			return null;
		}

		/// <summary>Converts the numeric value of this instance to its equivalent string representation, using the specified format.</summary>
		/// <param name="format">A standard or custom numeric format string.</param>
		/// <returns>The string representation of the value of this instance as specified by <paramref name="format" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.</exception>
		// Token: 0x060007C4 RID: 1988 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007C4")]
		[Address(RVA = "0x2AA4840", Offset = "0x2AA3640", VA = "0x182AA4840")]
		public string ToString(string format)
		{
			return null;
		}

		/// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.</summary>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of the value of this instance as specified by <paramref name="provider" />.</returns>
		// Token: 0x060007C5 RID: 1989 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007C5")]
		[Address(RVA = "0x2AA4880", Offset = "0x2AA3680", VA = "0x182AA4880", Slot = "21")]
		public string ToString(IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.</summary>
		/// <param name="format">A numeric format string.</param>
		/// <param name="provider">An object that supplies culture-specific formatting information.</param>
		/// <returns>The string representation of the value of this instance as specified by <paramref name="format" /> and <paramref name="provider" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="format" /> is invalid.</exception>
		// Token: 0x060007C6 RID: 1990 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007C6")]
		[Address(RVA = "0x2AA48C0", Offset = "0x2AA36C0", VA = "0x182AA48C0", Slot = "4")]
		public string ToString(string format, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Converts the string representation of a number to its <see cref="T:System.Decimal" /> equivalent using the specified culture-specific format information.</summary>
		/// <param name="s">The string representation of the number to convert.</param>
		/// <param name="provider">An <see cref="T:System.IFormatProvider" /> that supplies culture-specific parsing information about <paramref name="s" />.</param>
		/// <returns>The <see cref="T:System.Decimal" /> number equivalent to the number contained in <paramref name="s" /> as specified by <paramref name="provider" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="s" /> is not of the correct format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="s" /> represents a number less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007C7 RID: 1991 RVA: 0x000070F8 File Offset: 0x000052F8
		[Token(Token = "0x60007C7")]
		[Address(RVA = "0x2AA35A0", Offset = "0x2AA23A0", VA = "0x182AA35A0")]
		public static decimal Parse(string s, IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>Converts the string representation of a number to its <see cref="T:System.Decimal" /> equivalent using the specified style and culture-specific format.</summary>
		/// <param name="s">The string representation of the number to convert.</param>
		/// <param name="style">A bitwise combination of <see cref="T:System.Globalization.NumberStyles" /> values that indicates the style elements that can be present in <paramref name="s" />. A typical value to specify is <see cref="F:System.Globalization.NumberStyles.Number" />.</param>
		/// <param name="provider">An <see cref="T:System.IFormatProvider" /> object that supplies culture-specific information about the format of <paramref name="s" />.</param>
		/// <returns>The <see cref="T:System.Decimal" /> number equivalent to the number contained in <paramref name="s" /> as specified by <paramref name="style" /> and <paramref name="provider" />.</returns>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="s" /> is not in the correct format.</exception>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="s" /> represents a number less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="s" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="style" /> is not a <see cref="T:System.Globalization.NumberStyles" /> value.  
		/// -or-  
		/// <paramref name="style" /> is the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier" /> value.</exception>
		// Token: 0x060007C8 RID: 1992 RVA: 0x00007110 File Offset: 0x00005310
		[Token(Token = "0x60007C8")]
		[Address(RVA = "0x2AA35F0", Offset = "0x2AA23F0", VA = "0x182AA35F0")]
		public static decimal Parse(string s, NumberStyles style, IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>Converts the string representation of a number to its <see cref="T:System.Decimal" /> equivalent. A return value indicates whether the conversion succeeded or failed.</summary>
		/// <param name="s">The string representation of the number to convert.</param>
		/// <param name="result">When this method returns, contains the <see cref="T:System.Decimal" /> number that is equivalent to the numeric value contained in <paramref name="s" />, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the <paramref name="s" /> parameter is <see langword="null" /> or <see cref="F:System.String.Empty" />, is not a number in a valid format, or represents a number less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />. This parameter is passed uininitialized; any value originally supplied in <paramref name="result" /> is overwritten.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="s" /> was converted successfully; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007C9 RID: 1993 RVA: 0x00007128 File Offset: 0x00005328
		[Token(Token = "0x60007C9")]
		[Address(RVA = "0x2AA4CA0", Offset = "0x2AA3AA0", VA = "0x182AA4CA0")]
		public static bool TryParse(string s, out decimal result)
		{
			return default(bool);
		}

		/// <summary>Converts the string representation of a number to its <see cref="T:System.Decimal" /> equivalent using the specified style and culture-specific format. A return value indicates whether the conversion succeeded or failed.</summary>
		/// <param name="s">The string representation of the number to convert.</param>
		/// <param name="style">A bitwise combination of enumeration values that indicates the permitted format of <paramref name="s" />. A typical value to specify is <see cref="F:System.Globalization.NumberStyles.Number" />.</param>
		/// <param name="provider">An object that supplies culture-specific parsing information about <paramref name="s" />.</param>
		/// <param name="result">When this method returns, contains the <see cref="T:System.Decimal" /> number that is equivalent to the numeric value contained in <paramref name="s" />, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the <paramref name="s" /> parameter is <see langword="null" /> or <see cref="F:System.String.Empty" />, is not a number in a format compliant with <paramref name="style" />, or represents a number less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />. This parameter is passed uininitialized; any value originally supplied in <paramref name="result" /> is overwritten.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="s" /> was converted successfully; otherwise, <see langword="false" />.</returns>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="style" /> is not a <see cref="T:System.Globalization.NumberStyles" /> value.  
		/// -or-  
		/// <paramref name="style" /> is the <see cref="F:System.Globalization.NumberStyles.AllowHexSpecifier" /> value.</exception>
		// Token: 0x060007CA RID: 1994 RVA: 0x00007140 File Offset: 0x00005340
		[Token(Token = "0x60007CA")]
		[Address(RVA = "0x2AA4C40", Offset = "0x2AA3A40", VA = "0x182AA4C40")]
		public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out decimal result)
		{
			return default(bool);
		}

		/// <summary>Converts the value of a specified instance of <see cref="T:System.Decimal" /> to its equivalent binary representation.</summary>
		/// <param name="d">The value to convert.</param>
		/// <returns>A 32-bit signed integer array with four elements that contain the binary representation of <paramref name="d" />.</returns>
		// Token: 0x060007CB RID: 1995 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007CB")]
		[Address(RVA = "0x2AA3370", Offset = "0x2AA2170", VA = "0x182AA3370")]
		public static int[] GetBits(decimal d)
		{
			return null;
		}

		// Token: 0x060007CC RID: 1996 RVA: 0x00007158 File Offset: 0x00005358
		[Token(Token = "0x60007CC")]
		[Address(RVA = "0x2AA40F0", Offset = "0x2AA2EF0", VA = "0x182AA40F0")]
		internal static decimal ToDecimal(byte[] buffer)
		{
			return 0m;
		}

		// Token: 0x060007CD RID: 1997 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007CD")]
		[Address(RVA = "0x2AA3320", Offset = "0x2AA2120", VA = "0x182AA3320")]
		private static void FCallMultiply(ref decimal d1, ref decimal d2)
		{
		}

		/// <summary>Returns the result of multiplying the specified <see cref="T:System.Decimal" /> value by negative one.</summary>
		/// <param name="d">The value to negate.</param>
		/// <returns>A decimal number with the value of <paramref name="d" />, but the opposite sign.  
		///  -or-  
		///  Zero, if <paramref name="d" /> is zero.</returns>
		// Token: 0x060007CE RID: 1998 RVA: 0x00007170 File Offset: 0x00005370
		[Token(Token = "0x60007CE")]
		[Address(RVA = "0x2AA3460", Offset = "0x2AA2260", VA = "0x182AA3460")]
		public static decimal Negate(decimal d)
		{
			return 0m;
		}

		/// <summary>Rounds a <see cref="T:System.Decimal" /> value to a specified number of decimal places.</summary>
		/// <param name="d">A decimal number to round.</param>
		/// <param name="decimals">A value from 0 to 28 that specifies the number of decimal places to round to.</param>
		/// <returns>The decimal number equivalent to <paramref name="d" /> rounded to <paramref name="decimals" /> number of decimal places.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="decimals" /> is not a value from 0 to 28.</exception>
		// Token: 0x060007CF RID: 1999 RVA: 0x00007188 File Offset: 0x00005388
		[Token(Token = "0x60007CF")]
		[Address(RVA = "0x2AA3660", Offset = "0x2AA2460", VA = "0x182AA3660")]
		public static decimal Round(decimal d, int decimals)
		{
			return 0m;
		}

		// Token: 0x060007D0 RID: 2000 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D0")]
		[Address(RVA = "0x2AA3330", Offset = "0x2AA2130", VA = "0x182AA3330")]
		private static void FCallRound(ref decimal d, int decimals)
		{
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 8-bit unsigned integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>An 8-bit unsigned integer 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: 0x060007D1 RID: 2001 RVA: 0x000071A0 File Offset: 0x000053A0
		[Token(Token = "0x60007D1")]
		[Address(RVA = "0x2AA3FE0", Offset = "0x2AA2DE0", VA = "0x182AA3FE0")]
		public static byte ToByte(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 8-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>An 8-bit signed integer equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.SByte.MinValue" /> or greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x060007D2 RID: 2002 RVA: 0x000071B8 File Offset: 0x000053B8
		[Token(Token = "0x60007D2")]
		[Address(RVA = "0x2AA46D0", Offset = "0x2AA34D0", VA = "0x182AA46D0")]
		[CLSCompliant(false)]
		public static sbyte ToSByte(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 16-bit signed integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>A 16-bit signed integer equivalent to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Int16.MinValue" /> or greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x060007D3 RID: 2003 RVA: 0x000071D0 File Offset: 0x000053D0
		[Token(Token = "0x60007D3")]
		[Address(RVA = "0x2AA43F0", Offset = "0x2AA31F0", VA = "0x182AA43F0")]
		public static short ToInt16(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent double-precision floating-point number.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A double-precision floating-point number equivalent to <paramref name="d" />.</returns>
		// Token: 0x060007D4 RID: 2004 RVA: 0x000071E8 File Offset: 0x000053E8
		[Token(Token = "0x60007D4")]
		[Address(RVA = "0x2AA43D0", Offset = "0x2AA31D0", VA = "0x182AA43D0")]
		public static double ToDouble(decimal d)
		{
			return 0.0;
		}

		// Token: 0x060007D5 RID: 2005 RVA: 0x00007200 File Offset: 0x00005400
		[Token(Token = "0x60007D5")]
		[Address(RVA = "0x2AA3340", Offset = "0x2AA2140", VA = "0x182AA3340")]
		internal static int FCallToInt32(decimal d)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 32-bit signed integer.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A 32-bit signed integer equivalent to the value of <paramref name="d" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="d" /> is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060007D6 RID: 2006 RVA: 0x00007218 File Offset: 0x00005418
		[Token(Token = "0x60007D6")]
		[Address(RVA = "0x2AA4500", Offset = "0x2AA3300", VA = "0x182AA4500")]
		public static int ToInt32(decimal d)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 64-bit signed integer.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A 64-bit signed integer equivalent to the value of <paramref name="d" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="d" /> is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060007D7 RID: 2007 RVA: 0x00007230 File Offset: 0x00005430
		[Token(Token = "0x60007D7")]
		[Address(RVA = "0x2AA45E0", Offset = "0x2AA33E0", VA = "0x182AA45E0")]
		public static long ToInt64(decimal d)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 16-bit unsigned integer.</summary>
		/// <param name="value">The decimal number to convert.</param>
		/// <returns>A 16-bit unsigned integer equivalent to the value of <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is greater than <see cref="F:System.UInt16.MaxValue" /> or less than <see cref="F:System.UInt16.MinValue" />.</exception>
		// Token: 0x060007D8 RID: 2008 RVA: 0x00007248 File Offset: 0x00005448
		[Token(Token = "0x60007D8")]
		[Address(RVA = "0x2AA4900", Offset = "0x2AA3700", VA = "0x182AA4900")]
		[CLSCompliant(false)]
		public static ushort ToUInt16(decimal value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 32-bit unsigned integer.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A 32-bit unsigned integer equivalent to the value of <paramref name="d" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="d" /> is negative or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x060007D9 RID: 2009 RVA: 0x00007260 File Offset: 0x00005460
		[Token(Token = "0x60007D9")]
		[Address(RVA = "0x2AA4A10", Offset = "0x2AA3810", VA = "0x182AA4A10")]
		[CLSCompliant(false)]
		public static uint ToUInt32(decimal d)
		{
			return 0U;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent 64-bit unsigned integer.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A 64-bit unsigned integer equivalent to the value of <paramref name="d" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="d" /> is negative or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060007DA RID: 2010 RVA: 0x00007278 File Offset: 0x00005478
		[Token(Token = "0x60007DA")]
		[Address(RVA = "0x2AA4AF0", Offset = "0x2AA38F0", VA = "0x182AA4AF0")]
		[CLSCompliant(false)]
		public static ulong ToUInt64(decimal d)
		{
			return 0UL;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.Decimal" /> to the equivalent single-precision floating-point number.</summary>
		/// <param name="d">The decimal number to convert.</param>
		/// <returns>A single-precision floating-point number equivalent to the value of <paramref name="d" />.</returns>
		// Token: 0x060007DB RID: 2011 RVA: 0x00007290 File Offset: 0x00005490
		[Token(Token = "0x60007DB")]
		[Address(RVA = "0x2AA47E0", Offset = "0x2AA35E0", VA = "0x182AA47E0")]
		public static float ToSingle(decimal d)
		{
			return 0f;
		}

		/// <summary>Returns the integral digits of the specified <see cref="T:System.Decimal" />; any fractional digits are discarded.</summary>
		/// <param name="d">The decimal number to truncate.</param>
		/// <returns>The result of <paramref name="d" /> rounded toward zero, to the nearest whole number.</returns>
		// Token: 0x060007DC RID: 2012 RVA: 0x000072A8 File Offset: 0x000054A8
		[Token(Token = "0x60007DC")]
		[Address(RVA = "0x2AA4BD0", Offset = "0x2AA39D0", VA = "0x182AA4BD0")]
		public static decimal Truncate(decimal d)
		{
			return 0m;
		}

		// Token: 0x060007DD RID: 2013 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007DD")]
		[Address(RVA = "0x2AA3360", Offset = "0x2AA2160", VA = "0x182AA3360")]
		private static void FCallTruncate(ref decimal d)
		{
		}

		/// <summary>Defines an implicit conversion of an 8-bit unsigned integer to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The 8-bit unsigned integer to convert.</param>
		/// <returns>The converted 8-bit unsigned integer.</returns>
		// Token: 0x060007DE RID: 2014 RVA: 0x000072C0 File Offset: 0x000054C0
		[Token(Token = "0x60007DE")]
		[Address(RVA = "0x2AA5830", Offset = "0x2AA4630", VA = "0x182AA5830")]
		public static implicit operator decimal(byte value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of an 8-bit signed integer to a <see cref="T:System.Decimal" />.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The 8-bit signed integer to convert.</param>
		/// <returns>The converted 8-bit signed integer.</returns>
		// Token: 0x060007DF RID: 2015 RVA: 0x000072D8 File Offset: 0x000054D8
		[Token(Token = "0x60007DF")]
		[Address(RVA = "0x2AA58A0", Offset = "0x2AA46A0", VA = "0x182AA58A0")]
		[CLSCompliant(false)]
		public static implicit operator decimal(sbyte value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 16-bit signed integer to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The 16-bit signed integer to convert.</param>
		/// <returns>The converted 16-bit signed integer.</returns>
		// Token: 0x060007E0 RID: 2016 RVA: 0x000072F0 File Offset: 0x000054F0
		[Token(Token = "0x60007E0")]
		[Address(RVA = "0x2AA58D0", Offset = "0x2AA46D0", VA = "0x182AA58D0")]
		public static implicit operator decimal(short value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 16-bit unsigned integer to a <see cref="T:System.Decimal" />.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The 16-bit unsigned integer to convert.</param>
		/// <returns>The converted 16-bit unsigned integer.</returns>
		// Token: 0x060007E1 RID: 2017 RVA: 0x00007308 File Offset: 0x00005508
		[Token(Token = "0x60007E1")]
		[Address(RVA = "0x2AA5850", Offset = "0x2AA4650", VA = "0x182AA5850")]
		[CLSCompliant(false)]
		public static implicit operator decimal(ushort value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a Unicode character to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The Unicode character to convert.</param>
		/// <returns>The converted Unicode character.</returns>
		// Token: 0x060007E2 RID: 2018 RVA: 0x00007320 File Offset: 0x00005520
		[Token(Token = "0x60007E2")]
		[Address(RVA = "0x2AA5850", Offset = "0x2AA4650", VA = "0x182AA5850")]
		public static implicit operator decimal(char value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 32-bit signed integer to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The 32-bit signed integer to convert.</param>
		/// <returns>The converted 32-bit signed integer.</returns>
		// Token: 0x060007E3 RID: 2019 RVA: 0x00007338 File Offset: 0x00005538
		[Token(Token = "0x60007E3")]
		[Address(RVA = "0x2AA5870", Offset = "0x2AA4670", VA = "0x182AA5870")]
		public static implicit operator decimal(int value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 32-bit unsigned integer to a <see cref="T:System.Decimal" />.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The 32-bit unsigned integer to convert.</param>
		/// <returns>The converted 32-bit unsigned integer.</returns>
		// Token: 0x060007E4 RID: 2020 RVA: 0x00007350 File Offset: 0x00005550
		[Token(Token = "0x60007E4")]
		[Address(RVA = "0x2AA5800", Offset = "0x2AA4600", VA = "0x182AA5800")]
		[CLSCompliant(false)]
		public static implicit operator decimal(uint value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 64-bit signed integer to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The 64-bit signed integer to convert.</param>
		/// <returns>The converted 64-bit signed integer.</returns>
		// Token: 0x060007E5 RID: 2021 RVA: 0x00007368 File Offset: 0x00005568
		[Token(Token = "0x60007E5")]
		[Address(RVA = "0x2AA5900", Offset = "0x2AA4700", VA = "0x182AA5900")]
		public static implicit operator decimal(long value)
		{
			return 0m;
		}

		/// <summary>Defines an implicit conversion of a 64-bit unsigned integer to a <see cref="T:System.Decimal" />.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The 64-bit unsigned integer to convert.</param>
		/// <returns>The converted 64-bit unsigned integer.</returns>
		// Token: 0x060007E6 RID: 2022 RVA: 0x00007380 File Offset: 0x00005580
		[Token(Token = "0x60007E6")]
		[Address(RVA = "0x2AA5810", Offset = "0x2AA4610", VA = "0x182AA5810")]
		[CLSCompliant(false)]
		public static implicit operator decimal(ulong value)
		{
			return 0m;
		}

		/// <summary>Defines an explicit conversion of a single-precision floating-point number to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The single-precision floating-point number to convert.</param>
		/// <returns>The converted single-precision floating point number.</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" />.  
		/// -or-  
		/// <paramref name="value" /> is <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.PositiveInfinity" />, or <see cref="F:System.Single.NegativeInfinity" />.</exception>
		// Token: 0x060007E7 RID: 2023 RVA: 0x00007398 File Offset: 0x00005598
		[Token(Token = "0x60007E7")]
		[Address(RVA = "0x2AA5390", Offset = "0x2AA4190", VA = "0x182AA5390")]
		public static explicit operator decimal(float value)
		{
			return 0m;
		}

		/// <summary>Defines an explicit conversion of a double-precision floating-point number to a <see cref="T:System.Decimal" />.</summary>
		/// <param name="value">The double-precision floating-point number to convert.</param>
		/// <returns>The converted double-precision floating point number.</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" />.  
		/// -or-  
		/// <paramref name="value" /> is <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.PositiveInfinity" />, or <see cref="F:System.Double.NegativeInfinity" />.</exception>
		// Token: 0x060007E8 RID: 2024 RVA: 0x000073B0 File Offset: 0x000055B0
		[Token(Token = "0x60007E8")]
		[Address(RVA = "0x2AA5370", Offset = "0x2AA4170", VA = "0x182AA5370")]
		public static explicit operator decimal(double value)
		{
			return 0m;
		}

		/// <summary>Defines an explicit conversion of a <see cref="T:System.Decimal" /> to a 32-bit signed integer.</summary>
		/// <param name="value">The value to convert.</param>
		/// <returns>A 32-bit signed integer that represents the converted <see cref="T:System.Decimal" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060007E9 RID: 2025 RVA: 0x000073C8 File Offset: 0x000055C8
		[Token(Token = "0x60007E9")]
		[Address(RVA = "0x2AA55A0", Offset = "0x2AA43A0", VA = "0x182AA55A0")]
		public static explicit operator int(decimal value)
		{
			return 0;
		}

		/// <summary>Defines an explicit conversion of a <see cref="T:System.Decimal" /> to a 64-bit signed integer.</summary>
		/// <param name="value">The value to convert.</param>
		/// <returns>A 64-bit signed integer that represents the converted <see cref="T:System.Decimal" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x060007EA RID: 2026 RVA: 0x000073E0 File Offset: 0x000055E0
		[Token(Token = "0x60007EA")]
		[Address(RVA = "0x2AA5470", Offset = "0x2AA4270", VA = "0x182AA5470")]
		public static explicit operator long(decimal value)
		{
			return 0L;
		}

		/// <summary>Defines an explicit conversion of a <see cref="T:System.Decimal" /> to a 64-bit unsigned integer.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The value to convert.</param>
		/// <returns>A 64-bit unsigned integer that represents the converted <see cref="T:System.Decimal" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> is negative or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x060007EB RID: 2027 RVA: 0x000073F8 File Offset: 0x000055F8
		[Token(Token = "0x60007EB")]
		[Address(RVA = "0x2AA5600", Offset = "0x2AA4400", VA = "0x182AA5600")]
		[CLSCompliant(false)]
		public static explicit operator ulong(decimal value)
		{
			return 0UL;
		}

		/// <summary>Defines an explicit conversion of a <see cref="T:System.Decimal" /> to a single-precision floating-point number.</summary>
		/// <param name="value">The value to convert.</param>
		/// <returns>A single-precision floating-point number that represents the converted <see cref="T:System.Decimal" />.</returns>
		// Token: 0x060007EC RID: 2028 RVA: 0x00007410 File Offset: 0x00005610
		[Token(Token = "0x60007EC")]
		[Address(RVA = "0x2AA5410", Offset = "0x2AA4210", VA = "0x182AA5410")]
		public static explicit operator float(decimal value)
		{
			return 0f;
		}

		/// <summary>Defines an explicit conversion of a <see cref="T:System.Decimal" /> to a double-precision floating-point number.</summary>
		/// <param name="value">The value to convert.</param>
		/// <returns>A double-precision floating-point number that represents the converted <see cref="T:System.Decimal" />.</returns>
		// Token: 0x060007ED RID: 2029 RVA: 0x00007428 File Offset: 0x00005628
		[Token(Token = "0x60007ED")]
		[Address(RVA = "0x2AA53B0", Offset = "0x2AA41B0", VA = "0x182AA53B0")]
		public static explicit operator double(decimal value)
		{
			return 0.0;
		}

		/// <summary>Adds two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The first value to add.</param>
		/// <param name="d2">The second value to add.</param>
		/// <returns>The result of adding <paramref name="d1" /> and <paramref name="d2" />.</returns>
		/// <exception cref="T:System.OverflowException">The return value is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007EE RID: 2030 RVA: 0x00007440 File Offset: 0x00005640
		[Token(Token = "0x60007EE")]
		[Address(RVA = "0x2AA5200", Offset = "0x2AA4000", VA = "0x182AA5200")]
		public static decimal operator +(decimal d1, decimal d2)
		{
			return 0m;
		}

		/// <summary>Subtracts two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The minuend.</param>
		/// <param name="d2">The subtrahend.</param>
		/// <returns>The result of subtracting <paramref name="d2" /> from <paramref name="d1" />.</returns>
		/// <exception cref="T:System.OverflowException">The return value is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007EF RID: 2031 RVA: 0x00007458 File Offset: 0x00005658
		[Token(Token = "0x60007EF")]
		[Address(RVA = "0x2AA5B10", Offset = "0x2AA4910", VA = "0x182AA5B10")]
		public static decimal operator -(decimal d1, decimal d2)
		{
			return 0m;
		}

		/// <summary>Multiplies two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The first value to multiply.</param>
		/// <param name="d2">The second value to multiply.</param>
		/// <returns>The result of multiplying <paramref name="d1" /> by <paramref name="d2" />.</returns>
		/// <exception cref="T:System.OverflowException">The return value is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007F0 RID: 2032 RVA: 0x00007470 File Offset: 0x00005670
		[Token(Token = "0x60007F0")]
		[Address(RVA = "0x2AA5A90", Offset = "0x2AA4890", VA = "0x182AA5A90")]
		public static decimal operator *(decimal d1, decimal d2)
		{
			return 0m;
		}

		/// <summary>Divides two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The dividend.</param>
		/// <param name="d2">The divisor.</param>
		/// <returns>The result of dividing <paramref name="d1" /> by <paramref name="d2" />.</returns>
		/// <exception cref="T:System.DivideByZeroException">
		///   <paramref name="d2" /> is zero.</exception>
		/// <exception cref="T:System.OverflowException">The return value is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007F1 RID: 2033 RVA: 0x00007488 File Offset: 0x00005688
		[Token(Token = "0x60007F1")]
		[Address(RVA = "0x2AA5280", Offset = "0x2AA4080", VA = "0x182AA5280")]
		public static decimal operator /(decimal d1, decimal d2)
		{
			return 0m;
		}

		/// <summary>Returns a value that indicates whether two <see cref="T:System.Decimal" /> values are equal.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> and <paramref name="d2" /> are equal; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F2 RID: 2034 RVA: 0x000074A0 File Offset: 0x000056A0
		[Token(Token = "0x60007F2")]
		[Address(RVA = "0x2AA5300", Offset = "0x2AA4100", VA = "0x182AA5300")]
		public static bool operator ==(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns a value that indicates whether two <see cref="T:System.Decimal" /> objects have different values.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> and <paramref name="d2" /> are not equal; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F3 RID: 2035 RVA: 0x000074B8 File Offset: 0x000056B8
		[Token(Token = "0x60007F3")]
		[Address(RVA = "0x2AA5940", Offset = "0x2AA4740", VA = "0x182AA5940")]
		public static bool operator !=(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether a specified <see cref="T:System.Decimal" /> is less than another specified <see cref="T:System.Decimal" />.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> is less than <paramref name="d2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F4 RID: 2036 RVA: 0x000074D0 File Offset: 0x000056D0
		[Token(Token = "0x60007F4")]
		[Address(RVA = "0x2AA5A20", Offset = "0x2AA4820", VA = "0x182AA5A20")]
		public static bool operator <(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether a specified <see cref="T:System.Decimal" /> is less than or equal to another specified <see cref="T:System.Decimal" />.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> is less than or equal to <paramref name="d2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F5 RID: 2037 RVA: 0x000074E8 File Offset: 0x000056E8
		[Token(Token = "0x60007F5")]
		[Address(RVA = "0x2AA59B0", Offset = "0x2AA47B0", VA = "0x182AA59B0")]
		public static bool operator <=(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether a specified <see cref="T:System.Decimal" /> is greater than another specified <see cref="T:System.Decimal" />.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> is greater than <paramref name="d2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F6 RID: 2038 RVA: 0x00007500 File Offset: 0x00005700
		[Token(Token = "0x60007F6")]
		[Address(RVA = "0x2AA5790", Offset = "0x2AA4590", VA = "0x182AA5790")]
		public static bool operator >(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether a specified <see cref="T:System.Decimal" /> is greater than or equal to another specified <see cref="T:System.Decimal" />.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="d1" /> is greater than or equal to <paramref name="d2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F7 RID: 2039 RVA: 0x00007518 File Offset: 0x00005718
		[Token(Token = "0x60007F7")]
		[Address(RVA = "0x2AA5720", Offset = "0x2AA4520", VA = "0x182AA5720")]
		public static bool operator >=(decimal d1, decimal d2)
		{
			return default(bool);
		}

		/// <summary>Returns the <see cref="T:System.TypeCode" /> for value type <see cref="T:System.Decimal" />.</summary>
		/// <returns>The enumerated constant <see cref="F:System.TypeCode.Decimal" />.</returns>
		// Token: 0x060007F8 RID: 2040 RVA: 0x00007530 File Offset: 0x00005730
		[Token(Token = "0x60007F8")]
		[Address(RVA = "0x55CB90", Offset = "0x55B990", VA = "0x18055CB90", Slot = "6")]
		public TypeCode GetTypeCode()
		{
			return TypeCode.Empty;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToBoolean(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>
		///   <see langword="true" /> if the value of the current instance is not zero; otherwise, <see langword="false" />.</returns>
		// Token: 0x060007F9 RID: 2041 RVA: 0x00007548 File Offset: 0x00005748
		[Token(Token = "0x60007F9")]
		[Address(RVA = "0x2AA3800", Offset = "0x2AA2600", VA = "0x182AA3800", Slot = "7")]
		bool IConvertible.ToBoolean(IFormatProvider provider)
		{
			return default(bool);
		}

		/// <summary>This conversion is not supported. Attempting to use this method throws an <see cref="T:System.InvalidCastException" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>None. This conversion is not supported.</returns>
		/// <exception cref="T:System.InvalidCastException">In all cases.</exception>
		// Token: 0x060007FA RID: 2042 RVA: 0x00007560 File Offset: 0x00005760
		[Token(Token = "0x60007FA")]
		[Address(RVA = "0x2AA38E0", Offset = "0x2AA26E0", VA = "0x182AA38E0", Slot = "8")]
		char IConvertible.ToChar(IFormatProvider provider)
		{
			return '\0';
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToSByte(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.SByte" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.SByte.MinValue" /> or greater than <see cref="F:System.SByte.MaxValue" />.</exception>
		// Token: 0x060007FB RID: 2043 RVA: 0x00007578 File Offset: 0x00005778
		[Token(Token = "0x60007FB")]
		[Address(RVA = "0x2AA3C40", Offset = "0x2AA2A40", VA = "0x182AA3C40", Slot = "9")]
		sbyte IConvertible.ToSByte(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToByte(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Byte" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.Byte.MinValue" /> or greater than <see cref="F:System.Byte.MaxValue" />.</exception>
		// Token: 0x060007FC RID: 2044 RVA: 0x00007590 File Offset: 0x00005790
		[Token(Token = "0x60007FC")]
		[Address(RVA = "0x2AA3870", Offset = "0x2AA2670", VA = "0x182AA3870", Slot = "10")]
		byte IConvertible.ToByte(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt16(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Int16" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.Int16.MinValue" /> or greater than <see cref="F:System.Int16.MaxValue" />.</exception>
		// Token: 0x060007FD RID: 2045 RVA: 0x000075A8 File Offset: 0x000057A8
		[Token(Token = "0x60007FD")]
		[Address(RVA = "0x2AA3AF0", Offset = "0x2AA28F0", VA = "0x182AA3AF0", Slot = "11")]
		short IConvertible.ToInt16(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToUInt16(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.UInt16" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.UInt16.MinValue" /> or greater than <see cref="F:System.UInt16.MaxValue" />.</exception>
		// Token: 0x060007FE RID: 2046 RVA: 0x000075C0 File Offset: 0x000057C0
		[Token(Token = "0x60007FE")]
		[Address(RVA = "0x2AA3DB0", Offset = "0x2AA2BB0", VA = "0x182AA3DB0", Slot = "12")]
		ushort IConvertible.ToUInt16(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt32(System.IFormatProvider)" />.</summary>
		/// <param name="provider">The parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Int32" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.Int32.MinValue" /> or greater than <see cref="F:System.Int32.MaxValue" />.</exception>
		// Token: 0x060007FF RID: 2047 RVA: 0x000075D8 File Offset: 0x000057D8
		[Token(Token = "0x60007FF")]
		[Address(RVA = "0x2AA3B60", Offset = "0x2AA2960", VA = "0x182AA3B60", Slot = "13")]
		int IConvertible.ToInt32(IFormatProvider provider)
		{
			return 0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt32(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.UInt32" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.UInt32.MinValue" /> or greater than <see cref="F:System.UInt32.MaxValue" />.</exception>
		// Token: 0x06000800 RID: 2048 RVA: 0x000075F0 File Offset: 0x000057F0
		[Token(Token = "0x6000800")]
		[Address(RVA = "0x2AA3E20", Offset = "0x2AA2C20", VA = "0x182AA3E20", Slot = "14")]
		uint IConvertible.ToUInt32(IFormatProvider provider)
		{
			return 0U;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt64(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Int64" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.Int64.MinValue" /> or greater than <see cref="F:System.Int64.MaxValue" />.</exception>
		// Token: 0x06000801 RID: 2049 RVA: 0x00007608 File Offset: 0x00005808
		[Token(Token = "0x6000801")]
		[Address(RVA = "0x2AA3BD0", Offset = "0x2AA29D0", VA = "0x182AA3BD0", Slot = "15")]
		long IConvertible.ToInt64(IFormatProvider provider)
		{
			return 0L;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToInt64(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.UInt64" />.</returns>
		/// <exception cref="T:System.OverflowException">The resulting integer value is less than <see cref="F:System.UInt64.MinValue" /> or greater than <see cref="F:System.UInt64.MaxValue" />.</exception>
		// Token: 0x06000802 RID: 2050 RVA: 0x00007620 File Offset: 0x00005820
		[Token(Token = "0x6000802")]
		[Address(RVA = "0x2AA3E90", Offset = "0x2AA2C90", VA = "0x182AA3E90", Slot = "16")]
		ulong IConvertible.ToUInt64(IFormatProvider provider)
		{
			return 0UL;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToSingle(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Single" />.</returns>
		// Token: 0x06000803 RID: 2051 RVA: 0x00007638 File Offset: 0x00005838
		[Token(Token = "0x6000803")]
		[Address(RVA = "0x2AA3CB0", Offset = "0x2AA2AB0", VA = "0x182AA3CB0", Slot = "17")]
		float IConvertible.ToSingle(IFormatProvider provider)
		{
			return 0f;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToDouble(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, converted to a <see cref="T:System.Double" />.</returns>
		// Token: 0x06000804 RID: 2052 RVA: 0x00007650 File Offset: 0x00005850
		[Token(Token = "0x6000804")]
		[Address(RVA = "0x2AA3A80", Offset = "0x2AA2880", VA = "0x182AA3A80", Slot = "18")]
		double IConvertible.ToDouble(IFormatProvider provider)
		{
			return 0.0;
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToDecimal(System.IFormatProvider)" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>The value of the current instance, unchanged.</returns>
		// Token: 0x06000805 RID: 2053 RVA: 0x00007668 File Offset: 0x00005868
		[Token(Token = "0x6000805")]
		[Address(RVA = "0x723D40", Offset = "0x722B40", VA = "0x180723D40", Slot = "19")]
		decimal IConvertible.ToDecimal(IFormatProvider provider)
		{
			return 0m;
		}

		/// <summary>This conversion is not supported. Attempting to use this method throws an <see cref="T:System.InvalidCastException" />.</summary>
		/// <param name="provider">This parameter is ignored.</param>
		/// <returns>None. This conversion is not supported.</returns>
		/// <exception cref="T:System.InvalidCastException">In all cases.</exception>
		// Token: 0x06000806 RID: 2054 RVA: 0x00007680 File Offset: 0x00005880
		[Token(Token = "0x6000806")]
		[Address(RVA = "0x2AA39B0", Offset = "0x2AA27B0", VA = "0x182AA39B0", Slot = "20")]
		DateTime IConvertible.ToDateTime(IFormatProvider provider)
		{
			return default(DateTime);
		}

		/// <summary>For a description of this member, see <see cref="M:System.IConvertible.ToType(System.Type,System.IFormatProvider)" />.</summary>
		/// <param name="type">The type to which to convert the value of this <see cref="T:System.Decimal" /> instance.</param>
		/// <param name="provider">An <see cref="T:System.IFormatProvider" /> implementation that supplies culture-specific information about the format of the returned value.</param>
		/// <returns>The value of the current instance, converted to a <paramref name="type" />.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="type" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.InvalidCastException">The requested type conversion is not supported.</exception>
		// Token: 0x06000807 RID: 2055 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000807")]
		[Address(RVA = "0x2AA3D20", Offset = "0x2AA2B20", VA = "0x182AA3D20", Slot = "22")]
		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return null;
		}

		// Token: 0x0400031F RID: 799
		[Token(Token = "0x400031F")]
		private const int SignMask = -2147483648;

		// Token: 0x04000320 RID: 800
		[Token(Token = "0x4000320")]
		private const byte DECIMAL_NEG = 128;

		// Token: 0x04000321 RID: 801
		[Token(Token = "0x4000321")]
		private const byte DECIMAL_ADD = 0;

		// Token: 0x04000322 RID: 802
		[Token(Token = "0x4000322")]
		private const int ScaleMask = 16711680;

		// Token: 0x04000323 RID: 803
		[Token(Token = "0x4000323")]
		private const int ScaleShift = 16;

		// Token: 0x04000324 RID: 804
		[Token(Token = "0x4000324")]
		private const int MaxInt32Scale = 9;

		// Token: 0x04000325 RID: 805
		[Token(Token = "0x4000325")]
		private static uint[] Powers10;

		/// <summary>Represents the number zero (0).</summary>
		// Token: 0x04000326 RID: 806
		[Token(Token = "0x4000326")]
		public const decimal Zero = 0m;

		/// <summary>Represents the number one (1).</summary>
		// Token: 0x04000327 RID: 807
		[Token(Token = "0x4000327")]
		public const decimal One = 1m;

		/// <summary>Represents the number negative one (-1).</summary>
		// Token: 0x04000328 RID: 808
		[Token(Token = "0x4000328")]
		public const decimal MinusOne = -1m;

		/// <summary>Represents the largest possible value of <see cref="T:System.Decimal" />. This field is constant and read-only.</summary>
		// Token: 0x04000329 RID: 809
		[Token(Token = "0x4000329")]
		public const decimal MaxValue = 79228162514264337593543950335m;

		/// <summary>Represents the smallest possible value of <see cref="T:System.Decimal" />. This field is constant and read-only.</summary>
		// Token: 0x0400032A RID: 810
		[Token(Token = "0x400032A")]
		public const decimal MinValue = -79228162514264337593543950335m;

		// Token: 0x0400032B RID: 811
		[Token(Token = "0x400032B")]
		private const decimal NearNegativeZero = -0.000000000000000000000000001m;

		// Token: 0x0400032C RID: 812
		[Token(Token = "0x400032C")]
		private const decimal NearPositiveZero = 0.000000000000000000000000001m;

		// Token: 0x0400032D RID: 813
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
		[Token(Token = "0x400032D")]
		private int flags;

		// Token: 0x0400032E RID: 814
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
		[Token(Token = "0x400032E")]
		private int hi;

		// Token: 0x0400032F RID: 815
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
		[Token(Token = "0x400032F")]
		private int lo;

		// Token: 0x04000330 RID: 816
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
		[Token(Token = "0x4000330")]
		private int mid;
	}
}