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: 0x020000DB RID: 219
	[Token(Token = "0x20000DB")]
	[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: 0x060007CF RID: 1999 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007CF")]
		[Address(RVA = "0xD716F0", Offset = "0xD706F0", VA = "0x180D716F0")]
		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: 0x060007D0 RID: 2000 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D0")]
		[Address(RVA = "0xD716E0", Offset = "0xD706E0", VA = "0x180D716E0")]
		[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: 0x060007D1 RID: 2001 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D1")]
		[Address(RVA = "0xD718C0", Offset = "0xD708C0", VA = "0x180D718C0")]
		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: 0x060007D2 RID: 2002 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D2")]
		[Address(RVA = "0xD716D0", Offset = "0xD706D0", VA = "0x180D716D0")]
		[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: 0x060007D3 RID: 2003 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D3")]
		[Address(RVA = "0xD718B0", Offset = "0xD708B0", VA = "0x180D718B0")]
		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: 0x060007D4 RID: 2004 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D4")]
		[Address(RVA = "0xD71720", Offset = "0xD70720", VA = "0x180D71720")]
		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: 0x060007D5 RID: 2005 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D5")]
		[Address(RVA = "0xD715B0", Offset = "0xD705B0", VA = "0x180D715B0")]
		public Decimal(int[] bits)
		{
		}

		// Token: 0x060007D6 RID: 2006 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D6")]
		[Address(RVA = "0xD6FDD0", Offset = "0xD6EDD0", VA = "0x180D6FDD0")]
		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: 0x060007D7 RID: 2007 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D7")]
		[Address(RVA = "0xD71730", Offset = "0xD70730", VA = "0x180D71730")]
		public Decimal(int lo, int mid, int hi, bool isNegative, byte scale)
		{
		}

		// Token: 0x060007D8 RID: 2008 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D8")]
		[Address(RVA = "0xD6FBB0", Offset = "0xD6EBB0", VA = "0x180D6FBB0")]
		[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: 0x060007D9 RID: 2009 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007D9")]
		[Address(RVA = "0xD705F0", Offset = "0xD6F5F0", VA = "0x180D705F0", Slot = "23")]
		void IDeserializationCallback.OnDeserialization(object sender)
		{
		}

		// Token: 0x060007DA RID: 2010 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007DA")]
		[Address(RVA = "0xD717F0", Offset = "0xD707F0", VA = "0x180D717F0")]
		private Decimal(int lo, int mid, int hi, int flags)
		{
		}

		/// <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 sum of <paramref name="d1" /> and <paramref name="d2" />.</returns>
		/// <exception cref="T:System.OverflowException">The sum of <paramref name="d1" /> and <paramref name="d2" /> is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007DB RID: 2011 RVA: 0x000071A0 File Offset: 0x000053A0
		[Token(Token = "0x60007DB")]
		[Address(RVA = "0xD6F450", Offset = "0xD6E450", VA = "0x180D6F450")]
		public static decimal Add(decimal d1, decimal d2)
		{
			return 0m;
		}

		// Token: 0x060007DC RID: 2012 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007DC")]
		[Address(RVA = "0xD6F840", Offset = "0xD6E840", VA = "0x180D6F840")]
		private static void FCallAddSub(ref decimal d1, ref decimal d2, byte bSign)
		{
		}

		/// <summary>Compares two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The first value to compare.</param>
		/// <param name="d2">The second value to compare.</param>
		/// <returns>A signed number indicating the relative values of <paramref name="d1" /> and <paramref name="d2" />.  
		///   Return value  
		///
		///   Meaning  
		///
		///   Less than zero  
		///
		///  <paramref name="d1" /> is less than <paramref name="d2" />.  
		///
		///   Zero  
		///
		///  <paramref name="d1" /> and <paramref name="d2" /> are equal.  
		///
		///   Greater than zero  
		///
		///  <paramref name="d1" /> is greater than <paramref name="d2" />.</returns>
		// Token: 0x060007DD RID: 2013 RVA: 0x000071B8 File Offset: 0x000053B8
		[Token(Token = "0x60007DD")]
		[Address(RVA = "0xD6F630", Offset = "0xD6E630", VA = "0x180D6F630")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static int Compare(decimal d1, decimal d2)
		{
			return 0;
		}

		// Token: 0x060007DE RID: 2014 RVA: 0x000071D0 File Offset: 0x000053D0
		[Token(Token = "0x60007DE")]
		[Address(RVA = "0xD6F850", Offset = "0xD6E850", VA = "0x180D6F850")]
		[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: 0x060007DF RID: 2015 RVA: 0x000071E8 File Offset: 0x000053E8
		[Token(Token = "0x60007DF")]
		[Address(RVA = "0xD6F4D0", Offset = "0xD6E4D0", VA = "0x180D6F4D0", 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: 0x060007E0 RID: 2016 RVA: 0x00007200 File Offset: 0x00005400
		[Token(Token = "0x60007E0")]
		[Address(RVA = "0xD6F5D0", Offset = "0xD6E5D0", VA = "0x180D6F5D0", Slot = "24")]
		public int CompareTo(decimal value)
		{
			return 0;
		}

		/// <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 (that is, the quotient) is less than <see cref="F:System.Decimal.MinValue" /> or greater than <see cref="F:System.Decimal.MaxValue" />.</exception>
		// Token: 0x060007E1 RID: 2017 RVA: 0x00007218 File Offset: 0x00005418
		[Token(Token = "0x60007E1")]
		[Address(RVA = "0xD6F690", Offset = "0xD6E690", VA = "0x180D6F690")]
		public static decimal Divide(decimal d1, decimal d2)
		{
			return 0m;
		}

		// Token: 0x060007E2 RID: 2018 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007E2")]
		[Address(RVA = "0xD6F860", Offset = "0xD6E860", VA = "0x180D6F860")]
		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: 0x060007E3 RID: 2019 RVA: 0x00007230 File Offset: 0x00005430
		[Token(Token = "0x60007E3")]
		[Address(RVA = "0xD6F780", Offset = "0xD6E780", VA = "0x180D6F780", 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: 0x060007E4 RID: 2020 RVA: 0x00007248 File Offset: 0x00005448
		[Token(Token = "0x60007E4")]
		[Address(RVA = "0xD6F710", Offset = "0xD6E710", VA = "0x180D6F710", 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: 0x060007E5 RID: 2021 RVA: 0x00007260 File Offset: 0x00005460
		[Token(Token = "0x60007E5")]
		[Address(RVA = "0xD6F9A0", Offset = "0xD6E9A0", VA = "0x180D6F9A0", 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: 0x060007E6 RID: 2022 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007E6")]
		[Address(RVA = "0xD70EF0", Offset = "0xD6FEF0", VA = "0x180D70EF0", 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: 0x060007E7 RID: 2023 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007E7")]
		[Address(RVA = "0xD70F30", Offset = "0xD6FF30", VA = "0x180D70F30")]
		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: 0x060007E8 RID: 2024 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007E8")]
		[Address(RVA = "0xD70F70", Offset = "0xD6FF70", VA = "0x180D70F70", 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: 0x060007E9 RID: 2025 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007E9")]
		[Address(RVA = "0xD70FB0", Offset = "0xD6FFB0", VA = "0x180D70FB0", 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: 0x060007EA RID: 2026 RVA: 0x00007278 File Offset: 0x00005478
		[Token(Token = "0x60007EA")]
		[Address(RVA = "0xD6FC90", Offset = "0xD6EC90", VA = "0x180D6FC90")]
		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: 0x060007EB RID: 2027 RVA: 0x00007290 File Offset: 0x00005490
		[Token(Token = "0x60007EB")]
		[Address(RVA = "0xD6FCE0", Offset = "0xD6ECE0", VA = "0x180D6FCE0")]
		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: 0x060007EC RID: 2028 RVA: 0x000072A8 File Offset: 0x000054A8
		[Token(Token = "0x60007EC")]
		[Address(RVA = "0xD71390", Offset = "0xD70390", VA = "0x180D71390")]
		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: 0x060007ED RID: 2029 RVA: 0x000072C0 File Offset: 0x000054C0
		[Token(Token = "0x60007ED")]
		[Address(RVA = "0xD71330", Offset = "0xD70330", VA = "0x180D71330")]
		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: 0x060007EE RID: 2030 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60007EE")]
		[Address(RVA = "0xD6F8C0", Offset = "0xD6E8C0", VA = "0x180D6F8C0")]
		public static int[] GetBits(decimal d)
		{
			return null;
		}

		// Token: 0x060007EF RID: 2031 RVA: 0x000072D8 File Offset: 0x000054D8
		[Token(Token = "0x60007EF")]
		[Address(RVA = "0xD707E0", Offset = "0xD6F7E0", VA = "0x180D707E0")]
		internal static decimal ToDecimal(byte[] buffer)
		{
			return 0m;
		}

		// Token: 0x060007F0 RID: 2032 RVA: 0x000072F0 File Offset: 0x000054F0
		[Token(Token = "0x60007F0")]
		[Address(RVA = "0xD6F9B0", Offset = "0xD6E9B0", VA = "0x180D6F9B0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		internal static decimal Max(decimal d1, decimal d2)
		{
			return 0m;
		}

		// Token: 0x060007F1 RID: 2033 RVA: 0x00007308 File Offset: 0x00005508
		[Token(Token = "0x60007F1")]
		[Address(RVA = "0xD6FA40", Offset = "0xD6EA40", VA = "0x180D6FA40")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		internal static decimal Min(decimal d1, decimal d2)
		{
			return 0m;
		}

		/// <summary>Multiplies two specified <see cref="T:System.Decimal" /> values.</summary>
		/// <param name="d1">The multiplicand.</param>
		/// <param name="d2">The multiplier.</param>
		/// <returns>The result of multiplying <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: 0x060007F2 RID: 2034 RVA: 0x00007320 File Offset: 0x00005520
		[Token(Token = "0x60007F2")]
		[Address(RVA = "0xD6FAD0", Offset = "0xD6EAD0", VA = "0x180D6FAD0")]
		public static decimal Multiply(decimal d1, decimal d2)
		{
			return 0m;
		}

		// Token: 0x060007F3 RID: 2035 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007F3")]
		[Address(RVA = "0xD6F870", Offset = "0xD6E870", VA = "0x180D6F870")]
		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: 0x060007F4 RID: 2036 RVA: 0x00007338 File Offset: 0x00005538
		[Token(Token = "0x60007F4")]
		[Address(RVA = "0xD6FB50", Offset = "0xD6EB50", VA = "0x180D6FB50")]
		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: 0x060007F5 RID: 2037 RVA: 0x00007350 File Offset: 0x00005550
		[Token(Token = "0x60007F5")]
		[Address(RVA = "0xD6FD50", Offset = "0xD6ED50", VA = "0x180D6FD50")]
		public static decimal Round(decimal d, int decimals)
		{
			return 0m;
		}

		// Token: 0x060007F6 RID: 2038 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x60007F6")]
		[Address(RVA = "0xD6F880", Offset = "0xD6E880", VA = "0x180D6F880")]
		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: 0x060007F7 RID: 2039 RVA: 0x00007368 File Offset: 0x00005568
		[Token(Token = "0x60007F7")]
		[Address(RVA = "0xD706D0", Offset = "0xD6F6D0", VA = "0x180D706D0")]
		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: 0x060007F8 RID: 2040 RVA: 0x00007380 File Offset: 0x00005580
		[Token(Token = "0x60007F8")]
		[Address(RVA = "0xD70DC0", Offset = "0xD6FDC0", VA = "0x180D70DC0")]
		[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: 0x060007F9 RID: 2041 RVA: 0x00007398 File Offset: 0x00005598
		[Token(Token = "0x60007F9")]
		[Address(RVA = "0xD70AE0", Offset = "0xD6FAE0", VA = "0x180D70AE0")]
		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: 0x060007FA RID: 2042 RVA: 0x000073B0 File Offset: 0x000055B0
		[Token(Token = "0x60007FA")]
		[Address(RVA = "0xD70AC0", Offset = "0xD6FAC0", VA = "0x180D70AC0")]
		public static double ToDouble(decimal d)
		{
			return 0.0;
		}

		// Token: 0x060007FB RID: 2043 RVA: 0x000073C8 File Offset: 0x000055C8
		[Token(Token = "0x60007FB")]
		[Address(RVA = "0xD6F890", Offset = "0xD6E890", VA = "0x180D6F890")]
		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: 0x060007FC RID: 2044 RVA: 0x000073E0 File Offset: 0x000055E0
		[Token(Token = "0x60007FC")]
		[Address(RVA = "0xD70BF0", Offset = "0xD6FBF0", VA = "0x180D70BF0")]
		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: 0x060007FD RID: 2045 RVA: 0x000073F8 File Offset: 0x000055F8
		[Token(Token = "0x60007FD")]
		[Address(RVA = "0xD70CD0", Offset = "0xD6FCD0", VA = "0x180D70CD0")]
		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: 0x060007FE RID: 2046 RVA: 0x00007410 File Offset: 0x00005610
		[Token(Token = "0x60007FE")]
		[Address(RVA = "0xD70FF0", Offset = "0xD6FFF0", VA = "0x180D70FF0")]
		[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: 0x060007FF RID: 2047 RVA: 0x00007428 File Offset: 0x00005628
		[Token(Token = "0x60007FF")]
		[Address(RVA = "0xD71100", Offset = "0xD70100", VA = "0x180D71100")]
		[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: 0x06000800 RID: 2048 RVA: 0x00007440 File Offset: 0x00005640
		[Token(Token = "0x6000800")]
		[Address(RVA = "0xD711E0", Offset = "0xD701E0", VA = "0x180D711E0")]
		[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: 0x06000801 RID: 2049 RVA: 0x00007458 File Offset: 0x00005658
		[Token(Token = "0x6000801")]
		[Address(RVA = "0xD70ED0", Offset = "0xD6FED0", VA = "0x180D70ED0")]
		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: 0x06000802 RID: 2050 RVA: 0x00007470 File Offset: 0x00005670
		[Token(Token = "0x6000802")]
		[Address(RVA = "0xD712C0", Offset = "0xD702C0", VA = "0x180D712C0")]
		public static decimal Truncate(decimal d)
		{
			return 0m;
		}

		// Token: 0x06000803 RID: 2051 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000803")]
		[Address(RVA = "0xD6F8B0", Offset = "0xD6E8B0", VA = "0x180D6F8B0")]
		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: 0x06000804 RID: 2052 RVA: 0x00007488 File Offset: 0x00005688
		[Token(Token = "0x6000804")]
		[Address(RVA = "0xD71F20", Offset = "0xD70F20", VA = "0x180D71F20")]
		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: 0x06000805 RID: 2053 RVA: 0x000074A0 File Offset: 0x000056A0
		[Token(Token = "0x6000805")]
		[Address(RVA = "0xD71F90", Offset = "0xD70F90", VA = "0x180D71F90")]
		[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: 0x06000806 RID: 2054 RVA: 0x000074B8 File Offset: 0x000056B8
		[Token(Token = "0x6000806")]
		[Address(RVA = "0xD71FC0", Offset = "0xD70FC0", VA = "0x180D71FC0")]
		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: 0x06000807 RID: 2055 RVA: 0x000074D0 File Offset: 0x000056D0
		[Token(Token = "0x6000807")]
		[Address(RVA = "0xD71F40", Offset = "0xD70F40", VA = "0x180D71F40")]
		[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: 0x06000808 RID: 2056 RVA: 0x000074E8 File Offset: 0x000056E8
		[Token(Token = "0x6000808")]
		[Address(RVA = "0xD71F40", Offset = "0xD70F40", VA = "0x180D71F40")]
		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: 0x06000809 RID: 2057 RVA: 0x00007500 File Offset: 0x00005700
		[Token(Token = "0x6000809")]
		[Address(RVA = "0xD71F60", Offset = "0xD70F60", VA = "0x180D71F60")]
		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: 0x0600080A RID: 2058 RVA: 0x00007518 File Offset: 0x00005718
		[Token(Token = "0x600080A")]
		[Address(RVA = "0xD71EF0", Offset = "0xD70EF0", VA = "0x180D71EF0")]
		[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: 0x0600080B RID: 2059 RVA: 0x00007530 File Offset: 0x00005730
		[Token(Token = "0x600080B")]
		[Address(RVA = "0xD71FF0", Offset = "0xD70FF0", VA = "0x180D71FF0")]
		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: 0x0600080C RID: 2060 RVA: 0x00007548 File Offset: 0x00005748
		[Token(Token = "0x600080C")]
		[Address(RVA = "0xD71F00", Offset = "0xD70F00", VA = "0x180D71F00")]
		[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: 0x0600080D RID: 2061 RVA: 0x00007560 File Offset: 0x00005760
		[Token(Token = "0x600080D")]
		[Address(RVA = "0xD71A80", Offset = "0xD70A80", VA = "0x180D71A80")]
		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: 0x0600080E RID: 2062 RVA: 0x00007578 File Offset: 0x00005778
		[Token(Token = "0x600080E")]
		[Address(RVA = "0xD71A60", Offset = "0xD70A60", VA = "0x180D71A60")]
		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: 0x0600080F RID: 2063 RVA: 0x00007590 File Offset: 0x00005790
		[Token(Token = "0x600080F")]
		[Address(RVA = "0xD71C90", Offset = "0xD70C90", VA = "0x180D71C90")]
		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: 0x06000810 RID: 2064 RVA: 0x000075A8 File Offset: 0x000057A8
		[Token(Token = "0x6000810")]
		[Address(RVA = "0xD71B60", Offset = "0xD70B60", VA = "0x180D71B60")]
		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: 0x06000811 RID: 2065 RVA: 0x000075C0 File Offset: 0x000057C0
		[Token(Token = "0x6000811")]
		[Address(RVA = "0xD71CF0", Offset = "0xD70CF0", VA = "0x180D71CF0")]
		[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: 0x06000812 RID: 2066 RVA: 0x000075D8 File Offset: 0x000057D8
		[Token(Token = "0x6000812")]
		[Address(RVA = "0xD71B00", Offset = "0xD70B00", VA = "0x180D71B00")]
		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: 0x06000813 RID: 2067 RVA: 0x000075F0 File Offset: 0x000057F0
		[Token(Token = "0x6000813")]
		[Address(RVA = "0xD71AA0", Offset = "0xD70AA0", VA = "0x180D71AA0")]
		public static explicit operator double(decimal value)
		{
			return 0.0;
		}

		/// <summary>Negates the value of the specified <see cref="T:System.Decimal" /> operand.</summary>
		/// <param name="d">The value to negate.</param>
		/// <returns>The result of <paramref name="d" /> multiplied by negative one (-1).</returns>
		// Token: 0x06000814 RID: 2068 RVA: 0x00007608 File Offset: 0x00005808
		[Token(Token = "0x6000814")]
		[Address(RVA = "0xD72350", Offset = "0xD71350", VA = "0x180D72350")]
		public static decimal operator -(decimal d)
		{
			return 0m;
		}

		/// <summary>Increments the <see cref="T:System.Decimal" /> operand by 1.</summary>
		/// <param name="d">The value to increment.</param>
		/// <returns>The value of <paramref name="d" /> incremented by 1.</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: 0x06000815 RID: 2069 RVA: 0x00007620 File Offset: 0x00005820
		[Token(Token = "0x6000815")]
		[Address(RVA = "0xD72030", Offset = "0xD71030", VA = "0x180D72030")]
		public static decimal operator ++(decimal d)
		{
			return 0m;
		}

		/// <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: 0x06000816 RID: 2070 RVA: 0x00007638 File Offset: 0x00005838
		[Token(Token = "0x6000816")]
		[Address(RVA = "0xD718F0", Offset = "0xD708F0", VA = "0x180D718F0")]
		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: 0x06000817 RID: 2071 RVA: 0x00007650 File Offset: 0x00005850
		[Token(Token = "0x6000817")]
		[Address(RVA = "0xD722D0", Offset = "0xD712D0", VA = "0x180D722D0")]
		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: 0x06000818 RID: 2072 RVA: 0x00007668 File Offset: 0x00005868
		[Token(Token = "0x6000818")]
		[Address(RVA = "0xD72250", Offset = "0xD71250", VA = "0x180D72250")]
		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: 0x06000819 RID: 2073 RVA: 0x00007680 File Offset: 0x00005880
		[Token(Token = "0x6000819")]
		[Address(RVA = "0xD71970", Offset = "0xD70970", VA = "0x180D71970")]
		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: 0x0600081A RID: 2074 RVA: 0x00007698 File Offset: 0x00005898
		[Token(Token = "0x600081A")]
		[Address(RVA = "0xD719F0", Offset = "0xD709F0", VA = "0x180D719F0")]
		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: 0x0600081B RID: 2075 RVA: 0x000076B0 File Offset: 0x000058B0
		[Token(Token = "0x600081B")]
		[Address(RVA = "0xD72100", Offset = "0xD71100", VA = "0x180D72100")]
		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: 0x0600081C RID: 2076 RVA: 0x000076C8 File Offset: 0x000058C8
		[Token(Token = "0x600081C")]
		[Address(RVA = "0xD721E0", Offset = "0xD711E0", VA = "0x180D721E0")]
		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: 0x0600081D RID: 2077 RVA: 0x000076E0 File Offset: 0x000058E0
		[Token(Token = "0x600081D")]
		[Address(RVA = "0xD72170", Offset = "0xD71170", VA = "0x180D72170")]
		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: 0x0600081E RID: 2078 RVA: 0x000076F8 File Offset: 0x000058F8
		[Token(Token = "0x600081E")]
		[Address(RVA = "0xD71E80", Offset = "0xD70E80", VA = "0x180D71E80")]
		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: 0x0600081F RID: 2079 RVA: 0x00007710 File Offset: 0x00005910
		[Token(Token = "0x600081F")]
		[Address(RVA = "0xD71E10", Offset = "0xD70E10", VA = "0x180D71E10")]
		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: 0x06000820 RID: 2080 RVA: 0x00007728 File Offset: 0x00005928
		[Token(Token = "0x6000820")]
		[Address(RVA = "0x72B370", Offset = "0x72A370", VA = "0x18072B370", 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: 0x06000821 RID: 2081 RVA: 0x00007740 File Offset: 0x00005940
		[Token(Token = "0x6000821")]
		[Address(RVA = "0xD6FEF0", Offset = "0xD6EEF0", VA = "0x180D6FEF0", 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: 0x06000822 RID: 2082 RVA: 0x00007758 File Offset: 0x00005958
		[Token(Token = "0x6000822")]
		[Address(RVA = "0xD6FFD0", Offset = "0xD6EFD0", VA = "0x180D6FFD0", 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: 0x06000823 RID: 2083 RVA: 0x00007770 File Offset: 0x00005970
		[Token(Token = "0x6000823")]
		[Address(RVA = "0xD70330", Offset = "0xD6F330", VA = "0x180D70330", 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: 0x06000824 RID: 2084 RVA: 0x00007788 File Offset: 0x00005988
		[Token(Token = "0x6000824")]
		[Address(RVA = "0xD6FF60", Offset = "0xD6EF60", VA = "0x180D6FF60", 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: 0x06000825 RID: 2085 RVA: 0x000077A0 File Offset: 0x000059A0
		[Token(Token = "0x6000825")]
		[Address(RVA = "0xD701E0", Offset = "0xD6F1E0", VA = "0x180D701E0", 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: 0x06000826 RID: 2086 RVA: 0x000077B8 File Offset: 0x000059B8
		[Token(Token = "0x6000826")]
		[Address(RVA = "0xD704A0", Offset = "0xD6F4A0", VA = "0x180D704A0", 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: 0x06000827 RID: 2087 RVA: 0x000077D0 File Offset: 0x000059D0
		[Token(Token = "0x6000827")]
		[Address(RVA = "0xD70250", Offset = "0xD6F250", VA = "0x180D70250", 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: 0x06000828 RID: 2088 RVA: 0x000077E8 File Offset: 0x000059E8
		[Token(Token = "0x6000828")]
		[Address(RVA = "0xD70510", Offset = "0xD6F510", VA = "0x180D70510", 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: 0x06000829 RID: 2089 RVA: 0x00007800 File Offset: 0x00005A00
		[Token(Token = "0x6000829")]
		[Address(RVA = "0xD702C0", Offset = "0xD6F2C0", VA = "0x180D702C0", 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: 0x0600082A RID: 2090 RVA: 0x00007818 File Offset: 0x00005A18
		[Token(Token = "0x600082A")]
		[Address(RVA = "0xD70580", Offset = "0xD6F580", VA = "0x180D70580", 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: 0x0600082B RID: 2091 RVA: 0x00007830 File Offset: 0x00005A30
		[Token(Token = "0x600082B")]
		[Address(RVA = "0xD703A0", Offset = "0xD6F3A0", VA = "0x180D703A0", 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: 0x0600082C RID: 2092 RVA: 0x00007848 File Offset: 0x00005A48
		[Token(Token = "0x600082C")]
		[Address(RVA = "0xD70170", Offset = "0xD6F170", VA = "0x180D70170", 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: 0x0600082D RID: 2093 RVA: 0x00007860 File Offset: 0x00005A60
		[Token(Token = "0x600082D")]
		[Address(RVA = "0x814AC0", Offset = "0x813AC0", VA = "0x180814AC0", 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: 0x0600082E RID: 2094 RVA: 0x00007878 File Offset: 0x00005A78
		[Token(Token = "0x600082E")]
		[Address(RVA = "0xD700A0", Offset = "0xD6F0A0", VA = "0x180D700A0", 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: 0x0600082F RID: 2095 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600082F")]
		[Address(RVA = "0xD70410", Offset = "0xD6F410", VA = "0x180D70410", Slot = "22")]
		object IConvertible.ToType(Type type, IFormatProvider provider)
		{
			return null;
		}

		// Token: 0x04000329 RID: 809
		[Token(Token = "0x4000329")]
		private const int SignMask = -2147483648;

		// Token: 0x0400032A RID: 810
		[Token(Token = "0x400032A")]
		private const byte DECIMAL_NEG = 128;

		// Token: 0x0400032B RID: 811
		[Token(Token = "0x400032B")]
		private const byte DECIMAL_ADD = 0;

		// Token: 0x0400032C RID: 812
		[Token(Token = "0x400032C")]
		private const int ScaleMask = 16711680;

		// Token: 0x0400032D RID: 813
		[Token(Token = "0x400032D")]
		private const int ScaleShift = 16;

		// Token: 0x0400032E RID: 814
		[Token(Token = "0x400032E")]
		private const int MaxInt32Scale = 9;

		// Token: 0x0400032F RID: 815
		[Token(Token = "0x400032F")]
		private static uint[] Powers10;

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

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

		/// <summary>Represents the number negative one (-1).</summary>
		// Token: 0x04000332 RID: 818
		[Token(Token = "0x4000332")]
		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: 0x04000333 RID: 819
		[Token(Token = "0x4000333")]
		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: 0x04000334 RID: 820
		[Token(Token = "0x4000334")]
		public const decimal MinValue = -79228162514264337593543950335m;

		// Token: 0x04000335 RID: 821
		[Token(Token = "0x4000335")]
		private const decimal NearNegativeZero = -0.000000000000000000000000001m;

		// Token: 0x04000336 RID: 822
		[Token(Token = "0x4000336")]
		private const decimal NearPositiveZero = 0.000000000000000000000000001m;

		// Token: 0x04000337 RID: 823
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
		[Token(Token = "0x4000337")]
		private int flags;

		// Token: 0x04000338 RID: 824
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
		[Token(Token = "0x4000338")]
		private int hi;

		// Token: 0x04000339 RID: 825
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
		[Token(Token = "0x4000339")]
		private int lo;

		// Token: 0x0400033A RID: 826
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
		[Token(Token = "0x400033A")]
		private int mid;
	}
}