using System;
using System.Runtime.ConstrainedExecution;
using Cpp2IlInjected;

namespace System
{
	/// <summary>Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.</summary>
	// Token: 0x0200011C RID: 284
	[Token(Token = "0x200011C")]
	public static class Math
	{
		/// <summary>Returns the angle whose cosine is the specified number.</summary>
		/// <param name="d">A number representing a cosine, where <paramref name="d" /> must be greater than or equal to -1, but less than or equal to 1.</param>
		/// <returns>An angle, θ, measured in radians, such that 0 ≤θ≤π  
		///  -or-  
		///  <see cref="F:System.Double.NaN" /> if <paramref name="d" /> &lt; -1 or <paramref name="d" /> &gt; 1 or <paramref name="d" /> equals <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A4D RID: 2637 RVA: 0x000092A0 File Offset: 0x000074A0
		[Token(Token = "0x6000A4D")]
		[Address(RVA = "0x2D69930", Offset = "0x2D68930", VA = "0x182D69930")]
		public static double Acos(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the angle whose sine is the specified number.</summary>
		/// <param name="d">A number representing a sine, where <paramref name="d" /> must be greater than or equal to -1, but less than or equal to 1.</param>
		/// <returns>An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2  
		///  -or-  
		///  <see cref="F:System.Double.NaN" /> if <paramref name="d" /> &lt; -1 or <paramref name="d" /> &gt; 1 or <paramref name="d" /> equals <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A4E RID: 2638 RVA: 0x000092B8 File Offset: 0x000074B8
		[Token(Token = "0x6000A4E")]
		[Address(RVA = "0x2D69940", Offset = "0x2D68940", VA = "0x182D69940")]
		public static double Asin(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the angle whose tangent is the specified number.</summary>
		/// <param name="d">A number representing a tangent.</param>
		/// <returns>An angle, θ, measured in radians, such that -π/2 ≤θ≤π/2.  
		///  -or-  
		///  <see cref="F:System.Double.NaN" /> if <paramref name="d" /> equals <see cref="F:System.Double.NaN" />, -π/2 rounded to double precision (-1.5707963267949) if <paramref name="d" /> equals <see cref="F:System.Double.NegativeInfinity" />, or π/2 rounded to double precision (1.5707963267949) if <paramref name="d" /> equals <see cref="F:System.Double.PositiveInfinity" />.</returns>
		// Token: 0x06000A4F RID: 2639 RVA: 0x000092D0 File Offset: 0x000074D0
		[Token(Token = "0x6000A4F")]
		[Address(RVA = "0x2D69960", Offset = "0x2D68960", VA = "0x182D69960")]
		public static double Atan(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the angle whose tangent is the quotient of two specified numbers.</summary>
		/// <param name="y">The y coordinate of a point.</param>
		/// <param name="x">The x coordinate of a point.</param>
		/// <returns>An angle, θ, measured in radians, such that -π≤θ≤π, and tan(θ) = <paramref name="y" /> / <paramref name="x" />, where (<paramref name="x" />, <paramref name="y" />) is a point in the Cartesian plane. Observe the following:  
		///
		/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 1, 0 &lt; θ &lt; π/2.  
		///
		/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 2, π/2 &lt; θ≤π.  
		///
		/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 3, -π &lt; θ &lt; -π/2.  
		///
		/// For (<paramref name="x" />, <paramref name="y" />) in quadrant 4, -π/2 &lt; θ &lt; 0.  
		///
		///
		///  For points on the boundaries of the quadrants, the return value is the following:  
		///
		/// If y is 0 and x is not negative, θ = 0.  
		///
		/// If y is 0 and x is negative, θ = π.  
		///
		/// If y is positive and x is 0, θ = π/2.  
		///
		/// If y is negative and x is 0, θ = -π/2.  
		///
		/// If y is 0 and x is 0, θ = 0.  
		///
		///
		///  If <paramref name="x" /> or <paramref name="y" /> is <see cref="F:System.Double.NaN" />, or if <paramref name="x" /> and <paramref name="y" /> are either <see cref="F:System.Double.PositiveInfinity" /> or <see cref="F:System.Double.NegativeInfinity" />, the method returns <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A50 RID: 2640 RVA: 0x000092E8 File Offset: 0x000074E8
		[Token(Token = "0x6000A50")]
		[Address(RVA = "0x2D69950", Offset = "0x2D68950", VA = "0x182D69950")]
		public static double Atan2(double y, double x)
		{
			return 0.0;
		}

		/// <summary>Returns the smallest integral value that is greater than or equal to the specified double-precision floating-point number.</summary>
		/// <param name="a">A double-precision floating-point number.</param>
		/// <returns>The smallest integral value that is greater than or equal to <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, that value is returned. Note that this method returns a <see cref="T:System.Double" /> instead of an integral type.</returns>
		// Token: 0x06000A51 RID: 2641 RVA: 0x00009300 File Offset: 0x00007500
		[Token(Token = "0x6000A51")]
		[Address(RVA = "0x2D69970", Offset = "0x2D68970", VA = "0x182D69970")]
		public static double Ceiling(double a)
		{
			return 0.0;
		}

		/// <summary>Returns the cosine of the specified angle.</summary>
		/// <param name="d">An angle, measured in radians.</param>
		/// <returns>The cosine of <paramref name="d" />. If <paramref name="d" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A52 RID: 2642 RVA: 0x00009318 File Offset: 0x00007518
		[Token(Token = "0x6000A52")]
		[Address(RVA = "0x2D69980", Offset = "0x2D68980", VA = "0x182D69980")]
		public static double Cos(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the largest integral value less than or equal to the specified double-precision floating-point number.</summary>
		/// <param name="d">A double-precision floating-point number.</param>
		/// <returns>The largest integral value less than or equal to <paramref name="d" />. If <paramref name="d" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, that value is returned.</returns>
		// Token: 0x06000A53 RID: 2643 RVA: 0x00009330 File Offset: 0x00007530
		[Token(Token = "0x6000A53")]
		[Address(RVA = "0x2D699A0", Offset = "0x2D689A0", VA = "0x182D699A0")]
		public static double Floor(double d)
		{
			return 0.0;
		}

		// Token: 0x06000A54 RID: 2644 RVA: 0x00009348 File Offset: 0x00007548
		[Token(Token = "0x6000A54")]
		[Address(RVA = "0x2D69C30", Offset = "0x2D68C30", VA = "0x182D69C30")]
		private static double InternalRound(double value, int digits, MidpointRounding mode)
		{
			return 0.0;
		}

		// Token: 0x06000A55 RID: 2645 RVA: 0x00009360 File Offset: 0x00007560
		[Token(Token = "0x6000A55")]
		[Address(RVA = "0x2D69E00", Offset = "0x2D68E00", VA = "0x182D69E00")]
		private static double InternalTruncate(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the sine of the specified angle.</summary>
		/// <param name="a">An angle, measured in radians.</param>
		/// <returns>The sine of <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A56 RID: 2646 RVA: 0x00009378 File Offset: 0x00007578
		[Token(Token = "0x6000A56")]
		[Address(RVA = "0x2D6A7D0", Offset = "0x2D697D0", VA = "0x182D6A7D0")]
		public static double Sin(double a)
		{
			return 0.0;
		}

		/// <summary>Returns the tangent of the specified angle.</summary>
		/// <param name="a">An angle, measured in radians.</param>
		/// <returns>The tangent of <paramref name="a" />. If <paramref name="a" /> is equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NegativeInfinity" />, or <see cref="F:System.Double.PositiveInfinity" />, this method returns <see cref="F:System.Double.NaN" />.</returns>
		// Token: 0x06000A57 RID: 2647 RVA: 0x00009390 File Offset: 0x00007590
		[Token(Token = "0x6000A57")]
		[Address(RVA = "0x2D6A800", Offset = "0x2D69800", VA = "0x182D6A800")]
		public static double Tan(double a)
		{
			return 0.0;
		}

		/// <summary>Rounds a double-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number.</summary>
		/// <param name="a">A double-precision floating-point number to be rounded.</param>
		/// <returns>The integer nearest <paramref name="a" />. If the fractional component of <paramref name="a" /> is halfway between two integers, one of which is even and the other odd, then the even number is returned. Note that this method returns a <see cref="T:System.Double" /> instead of an integral type.</returns>
		// Token: 0x06000A58 RID: 2648 RVA: 0x000093A8 File Offset: 0x000075A8
		[Token(Token = "0x6000A58")]
		[Address(RVA = "0x2D6A4B0", Offset = "0x2D694B0", VA = "0x182D6A4B0")]
		public static double Round(double a)
		{
			return 0.0;
		}

		/// <summary>Rounds a double-precision floating-point value to a specified number of fractional digits, and rounds midpoint values to the nearest even number.</summary>
		/// <param name="value">A double-precision floating-point number to be rounded.</param>
		/// <param name="digits">The number of fractional digits in the return value.</param>
		/// <returns>The number nearest to <paramref name="value" /> that contains a number of fractional digits equal to <paramref name="digits" />.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="digits" /> is less than 0 or greater than 15.</exception>
		// Token: 0x06000A59 RID: 2649 RVA: 0x000093C0 File Offset: 0x000075C0
		[Token(Token = "0x6000A59")]
		[Address(RVA = "0x2D6A3F0", Offset = "0x2D693F0", VA = "0x182D6A3F0")]
		public static double Round(double value, int digits)
		{
			return 0.0;
		}

		/// <summary>Rounds a double-precision floating-point value to a specified number of fractional digits, and uses the specified rounding convention for midpoint values.</summary>
		/// <param name="value">A double-precision floating-point number to be rounded.</param>
		/// <param name="digits">The number of fractional digits in the return value.</param>
		/// <param name="mode">Specification for how to round <paramref name="value" /> if it is midway between two other numbers.</param>
		/// <returns>The number nearest to <paramref name="value" /> that has a number of fractional digits equal to <paramref name="digits" />. If <paramref name="value" /> has fewer fractional digits than <paramref name="digits" />, <paramref name="value" /> is returned unchanged.</returns>
		/// <exception cref="T:System.ArgumentOutOfRangeException">
		///   <paramref name="digits" /> is less than 0 or greater than 15.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="mode" /> is not a valid value of <see cref="T:System.MidpointRounding" />.</exception>
		// Token: 0x06000A5A RID: 2650 RVA: 0x000093D8 File Offset: 0x000075D8
		[Token(Token = "0x6000A5A")]
		[Address(RVA = "0x2D6A4C0", Offset = "0x2D694C0", VA = "0x182D6A4C0")]
		public static double Round(double value, int digits, MidpointRounding mode)
		{
			return 0.0;
		}

		/// <summary>Rounds a decimal value to the nearest integral value, and rounds midpoint values to the nearest even number.</summary>
		/// <param name="d">A decimal number to be rounded.</param>
		/// <returns>The integer nearest the <paramref name="d" /> parameter. If the fractional component of <paramref name="d" /> is halfway between two integers, one of which is even and the other odd, the even number is returned. Note that this method returns a <see cref="T:System.Decimal" /> instead of an integral type.</returns>
		/// <exception cref="T:System.OverflowException">The result is outside the range of a <see cref="T:System.Decimal" />.</exception>
		// Token: 0x06000A5B RID: 2651 RVA: 0x000093F0 File Offset: 0x000075F0
		[Token(Token = "0x6000A5B")]
		[Address(RVA = "0x2D6A650", Offset = "0x2D69650", VA = "0x182D6A650")]
		public static decimal Round(decimal d)
		{
			return 0m;
		}

		// Token: 0x06000A5C RID: 2652 RVA: 0x00009408 File Offset: 0x00007608
		[Token(Token = "0x6000A5C")]
		[Address(RVA = "0x2D6A7E0", Offset = "0x2D697E0", VA = "0x182D6A7E0")]
		private unsafe static double SplitFractionDouble(double* value)
		{
			return 0.0;
		}

		/// <summary>Calculates the integral part of a specified double-precision floating-point number.</summary>
		/// <param name="d">A number to truncate.</param>
		/// <returns>The integral part of <paramref name="d" />; that is, the number that remains after any fractional digits have been discarded, or one of the values listed in the following table.  
		///  <paramref name="d" /> Return value  
		///
		///  <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /><see cref="F:System.Double.NegativeInfinity" /><see cref="F:System.Double.NegativeInfinity" /><see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
		// Token: 0x06000A5D RID: 2653 RVA: 0x00009420 File Offset: 0x00007620
		[Token(Token = "0x6000A5D")]
		[Address(RVA = "0x2D6A810", Offset = "0x2D69810", VA = "0x182D6A810")]
		public static double Truncate(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the square root of a specified number.</summary>
		/// <param name="d">The number whose square root is to be found.</param>
		/// <returns>One of the values in the following table.  
		///  <paramref name="d" /> parameter  
		///
		///   Return value  
		///
		///   Zero or positive  
		///
		///   The positive square root of <paramref name="d" />.  
		///
		///   Negative  
		///
		///  <see cref="F:System.Double.NaN" /> Equals <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equals <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
		// Token: 0x06000A5E RID: 2654 RVA: 0x00009438 File Offset: 0x00007638
		[Token(Token = "0x6000A5E")]
		[Address(RVA = "0x2D6A7F0", Offset = "0x2D697F0", VA = "0x182D6A7F0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static double Sqrt(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the natural (base <see langword="e" />) logarithm of a specified number.</summary>
		/// <param name="d">The number whose logarithm is to be found.</param>
		/// <returns>One of the values in the following table.  
		///  <paramref name="d" /> parameter  
		///
		///   Return value  
		///
		///   Positive  
		///
		///   The natural logarithm of <paramref name="d" />; that is, ln <paramref name="d" />, or log e <paramref name="d" /> Zero  
		///
		///  <see cref="F:System.Double.NegativeInfinity" /> Negative  
		///
		///  <see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
		// Token: 0x06000A5F RID: 2655 RVA: 0x00009450 File Offset: 0x00007650
		[Token(Token = "0x6000A5F")]
		[Address(RVA = "0x2D69FD0", Offset = "0x2D68FD0", VA = "0x182D69FD0")]
		public static double Log(double d)
		{
			return 0.0;
		}

		/// <summary>Returns the base 10 logarithm of a specified number.</summary>
		/// <param name="d">A number whose logarithm is to be found.</param>
		/// <returns>One of the values in the following table.  
		///  <paramref name="d" /> parameter  
		///
		///   Return value  
		///
		///   Positive  
		///
		///   The base 10 log of <paramref name="d" />; that is, log 10<paramref name="d" />.  
		///
		///   Zero  
		///
		///  <see cref="F:System.Double.NegativeInfinity" /> Negative  
		///
		///  <see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.NaN" /><see cref="F:System.Double.NaN" /> Equal to <see cref="F:System.Double.PositiveInfinity" /><see cref="F:System.Double.PositiveInfinity" /></returns>
		// Token: 0x06000A60 RID: 2656 RVA: 0x00009468 File Offset: 0x00007668
		[Token(Token = "0x6000A60")]
		[Address(RVA = "0x2D69E60", Offset = "0x2D68E60", VA = "0x182D69E60")]
		public static double Log10(double d)
		{
			return 0.0;
		}

		/// <summary>Returns <see langword="e" /> raised to the specified power.</summary>
		/// <param name="d">A number specifying a power.</param>
		/// <returns>The number <see langword="e" /> raised to the power <paramref name="d" />. If <paramref name="d" /> equals <see cref="F:System.Double.NaN" /> or <see cref="F:System.Double.PositiveInfinity" />, that value is returned. If <paramref name="d" /> equals <see cref="F:System.Double.NegativeInfinity" />, 0 is returned.</returns>
		// Token: 0x06000A61 RID: 2657 RVA: 0x00009480 File Offset: 0x00007680
		[Token(Token = "0x6000A61")]
		[Address(RVA = "0x2D69990", Offset = "0x2D68990", VA = "0x182D69990")]
		public static double Exp(double d)
		{
			return 0.0;
		}

		/// <summary>Returns a specified number raised to the specified power.</summary>
		/// <param name="x">A double-precision floating-point number to be raised to a power.</param>
		/// <param name="y">A double-precision floating-point number that specifies a power.</param>
		/// <returns>The number <paramref name="x" /> raised to the power <paramref name="y" />.</returns>
		// Token: 0x06000A62 RID: 2658 RVA: 0x00009498 File Offset: 0x00007698
		[Token(Token = "0x6000A62")]
		[Address(RVA = "0x2D6A3E0", Offset = "0x2D693E0", VA = "0x182D6A3E0")]
		public static double Pow(double x, double y)
		{
			return 0.0;
		}

		/// <summary>Returns the remainder resulting from the division of a specified number by another specified number.</summary>
		/// <param name="x">A dividend.</param>
		/// <param name="y">A divisor.</param>
		/// <returns>A number equal to <paramref name="x" /> - (<paramref name="y" /> Q), where Q is the quotient of <paramref name="x" /> / <paramref name="y" /> rounded to the nearest integer (if <paramref name="x" /> / <paramref name="y" /> falls halfway between two integers, the even integer is returned).  
		///  If <paramref name="x" /> - (<paramref name="y" /> Q) is zero, the value +0 is returned if <paramref name="x" /> is positive, or -0 if <paramref name="x" /> is negative.  
		///  If <paramref name="y" /> = 0, <see cref="F:System.Double.NaN" /> is returned.</returns>
		// Token: 0x06000A63 RID: 2659 RVA: 0x000094B0 File Offset: 0x000076B0
		[Token(Token = "0x6000A63")]
		[Address(RVA = "0x2D699B0", Offset = "0x2D689B0", VA = "0x182D699B0")]
		public static double IEEERemainder(double x, double y)
		{
			return 0.0;
		}

		/// <summary>Returns the absolute value of a 32-bit signed integer.</summary>
		/// <param name="value">A number that is greater than <see cref="F:System.Int32.MinValue" />, but less than or equal to <see cref="F:System.Int32.MaxValue" />.</param>
		/// <returns>A 32-bit signed integer, x, such that 0 ≤ x ≤<see cref="F:System.Int32.MaxValue" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> equals <see cref="F:System.Int32.MinValue" />.</exception>
		// Token: 0x06000A64 RID: 2660 RVA: 0x000094C8 File Offset: 0x000076C8
		[Token(Token = "0x6000A64")]
		[Address(RVA = "0x2D69850", Offset = "0x2D68850", VA = "0x182D69850")]
		public static int Abs(int value)
		{
			return 0;
		}

		// Token: 0x06000A65 RID: 2661 RVA: 0x000094E0 File Offset: 0x000076E0
		[Token(Token = "0x6000A65")]
		[Address(RVA = "0x2D696F0", Offset = "0x2D686F0", VA = "0x182D696F0")]
		private static int AbsHelper(int value)
		{
			return 0;
		}

		/// <summary>Returns the absolute value of a 64-bit signed integer.</summary>
		/// <param name="value">A number that is greater than <see cref="F:System.Int64.MinValue" />, but less than or equal to <see cref="F:System.Int64.MaxValue" />.</param>
		/// <returns>A 64-bit signed integer, x, such that 0 ≤ x ≤<see cref="F:System.Int64.MaxValue" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> equals <see cref="F:System.Int64.MinValue" />.</exception>
		// Token: 0x06000A66 RID: 2662 RVA: 0x000094F8 File Offset: 0x000076F8
		[Token(Token = "0x6000A66")]
		[Address(RVA = "0x2D69770", Offset = "0x2D68770", VA = "0x182D69770")]
		public static long Abs(long value)
		{
			return 0L;
		}

		// Token: 0x06000A67 RID: 2663 RVA: 0x00009510 File Offset: 0x00007710
		[Token(Token = "0x6000A67")]
		[Address(RVA = "0x2D69660", Offset = "0x2D68660", VA = "0x182D69660")]
		private static long AbsHelper(long value)
		{
			return 0L;
		}

		/// <summary>Returns the absolute value of a single-precision floating-point number.</summary>
		/// <param name="value">A number that is greater than or equal to <see cref="F:System.Single.MinValue" />, but less than or equal to <see cref="F:System.Single.MaxValue" />.</param>
		/// <returns>A single-precision floating-point number, x, such that 0 ≤ x ≤<see cref="F:System.Single.MaxValue" />.</returns>
		// Token: 0x06000A68 RID: 2664 RVA: 0x00009528 File Offset: 0x00007728
		[Token(Token = "0x6000A68")]
		[Address(RVA = "0x2D69910", Offset = "0x2D68910", VA = "0x182D69910")]
		public static float Abs(float value)
		{
			return 0f;
		}

		/// <summary>Returns the absolute value of a double-precision floating-point number.</summary>
		/// <param name="value">A number that is greater than or equal to <see cref="F:System.Double.MinValue" />, but less than or equal to <see cref="F:System.Double.MaxValue" />.</param>
		/// <returns>A double-precision floating-point number, x, such that 0 ≤ x ≤<see cref="F:System.Double.MaxValue" />.</returns>
		// Token: 0x06000A69 RID: 2665 RVA: 0x00009540 File Offset: 0x00007740
		[Token(Token = "0x6000A69")]
		[Address(RVA = "0x2D69840", Offset = "0x2D68840", VA = "0x182D69840")]
		public static double Abs(double value)
		{
			return 0.0;
		}

		/// <summary>Returns the larger of two 8-bit signed integers.</summary>
		/// <param name="val1">The first of two 8-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 8-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6A RID: 2666 RVA: 0x00009558 File Offset: 0x00007758
		[Token(Token = "0x6000A6A")]
		[Address(RVA = "0x2D6A080", Offset = "0x2D69080", VA = "0x182D6A080")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static sbyte Max(sbyte val1, sbyte val2)
		{
			return 0;
		}

		/// <summary>Returns the larger of two 8-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 8-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 8-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6B RID: 2667 RVA: 0x00009570 File Offset: 0x00007770
		[Token(Token = "0x6000A6B")]
		[Address(RVA = "0x2D69FF0", Offset = "0x2D68FF0", VA = "0x182D69FF0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static byte Max(byte val1, byte val2)
		{
			return 0;
		}

		/// <summary>Returns the larger of two 16-bit signed integers.</summary>
		/// <param name="val1">The first of two 16-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 16-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6C RID: 2668 RVA: 0x00009588 File Offset: 0x00007788
		[Token(Token = "0x6000A6C")]
		[Address(RVA = "0x2D6A1D0", Offset = "0x2D691D0", VA = "0x182D6A1D0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static short Max(short val1, short val2)
		{
			return 0;
		}

		/// <summary>Returns the larger of two 16-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 16-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 16-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6D RID: 2669 RVA: 0x000095A0 File Offset: 0x000077A0
		[Token(Token = "0x6000A6D")]
		[Address(RVA = "0x2D6A010", Offset = "0x2D69010", VA = "0x182D6A010")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static ushort Max(ushort val1, ushort val2)
		{
			return 0;
		}

		/// <summary>Returns the larger of two 32-bit signed integers.</summary>
		/// <param name="val1">The first of two 32-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 32-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6E RID: 2670 RVA: 0x000095B8 File Offset: 0x000077B8
		[Token(Token = "0x6000A6E")]
		[Address(RVA = "0x2D6A130", Offset = "0x2D69130", VA = "0x182D6A130")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static int Max(int val1, int val2)
		{
			return 0;
		}

		/// <summary>Returns the larger of two 32-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 32-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 32-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A6F RID: 2671 RVA: 0x000095D0 File Offset: 0x000077D0
		[Token(Token = "0x6000A6F")]
		[Address(RVA = "0x2D6A000", Offset = "0x2D69000", VA = "0x182D6A000")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static uint Max(uint val1, uint val2)
		{
			return 0U;
		}

		/// <summary>Returns the larger of two 64-bit signed integers.</summary>
		/// <param name="val1">The first of two 64-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 64-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A70 RID: 2672 RVA: 0x000095E8 File Offset: 0x000077E8
		[Token(Token = "0x6000A70")]
		[Address(RVA = "0x2D69FE0", Offset = "0x2D68FE0", VA = "0x182D69FE0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static long Max(long val1, long val2)
		{
			return 0L;
		}

		/// <summary>Returns the larger of two 64-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 64-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 64-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A71 RID: 2673 RVA: 0x00009600 File Offset: 0x00007800
		[Token(Token = "0x6000A71")]
		[Address(RVA = "0x2D6A070", Offset = "0x2D69070", VA = "0x182D6A070")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static ulong Max(ulong val1, ulong val2)
		{
			return 0UL;
		}

		/// <summary>Returns the larger of two single-precision floating-point numbers.</summary>
		/// <param name="val1">The first of two single-precision floating-point numbers to compare.</param>
		/// <param name="val2">The second of two single-precision floating-point numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger. If <paramref name="val1" />, or <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.NaN" /> is returned.</returns>
		// Token: 0x06000A72 RID: 2674 RVA: 0x00009618 File Offset: 0x00007818
		[Token(Token = "0x6000A72")]
		[Address(RVA = "0x2D6A020", Offset = "0x2D69020", VA = "0x182D6A020")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static float Max(float val1, float val2)
		{
			return 0f;
		}

		/// <summary>Returns the larger of two double-precision floating-point numbers.</summary>
		/// <param name="val1">The first of two double-precision floating-point numbers to compare.</param>
		/// <param name="val2">The second of two double-precision floating-point numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NaN" /> is returned.</returns>
		// Token: 0x06000A73 RID: 2675 RVA: 0x00009630 File Offset: 0x00007830
		[Token(Token = "0x6000A73")]
		[Address(RVA = "0x2D6A140", Offset = "0x2D69140", VA = "0x182D6A140")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static double Max(double val1, double val2)
		{
			return 0.0;
		}

		/// <summary>Returns the larger of two decimal numbers.</summary>
		/// <param name="val1">The first of two decimal numbers to compare.</param>
		/// <param name="val2">The second of two decimal numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is larger.</returns>
		// Token: 0x06000A74 RID: 2676 RVA: 0x00009648 File Offset: 0x00007848
		[Token(Token = "0x6000A74")]
		[Address(RVA = "0x2D6A090", Offset = "0x2D69090", VA = "0x182D6A090")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static decimal Max(decimal val1, decimal val2)
		{
			return 0m;
		}

		/// <summary>Returns the smaller of two 8-bit signed integers.</summary>
		/// <param name="val1">The first of two 8-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 8-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A75 RID: 2677 RVA: 0x00009660 File Offset: 0x00007860
		[Token(Token = "0x6000A75")]
		[Address(RVA = "0x2D6A3D0", Offset = "0x2D693D0", VA = "0x182D6A3D0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[CLSCompliant(false)]
		public static sbyte Min(sbyte val1, sbyte val2)
		{
			return 0;
		}

		/// <summary>Returns the smaller of two 8-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 8-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 8-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A76 RID: 2678 RVA: 0x00009678 File Offset: 0x00007878
		[Token(Token = "0x6000A76")]
		[Address(RVA = "0x2D6A290", Offset = "0x2D69290", VA = "0x182D6A290")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static byte Min(byte val1, byte val2)
		{
			return 0;
		}

		/// <summary>Returns the smaller of two 16-bit signed integers.</summary>
		/// <param name="val1">The first of two 16-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 16-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A77 RID: 2679 RVA: 0x00009690 File Offset: 0x00007890
		[Token(Token = "0x6000A77")]
		[Address(RVA = "0x2D6A2A0", Offset = "0x2D692A0", VA = "0x182D6A2A0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static short Min(short val1, short val2)
		{
			return 0;
		}

		/// <summary>Returns the smaller of two 16-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 16-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 16-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A78 RID: 2680 RVA: 0x000096A8 File Offset: 0x000078A8
		[Token(Token = "0x6000A78")]
		[Address(RVA = "0x2D6A270", Offset = "0x2D69270", VA = "0x182D6A270")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static ushort Min(ushort val1, ushort val2)
		{
			return 0;
		}

		/// <summary>Returns the smaller of two 32-bit signed integers.</summary>
		/// <param name="val1">The first of two 32-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 32-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A79 RID: 2681 RVA: 0x000096C0 File Offset: 0x000078C0
		[Token(Token = "0x6000A79")]
		[Address(RVA = "0x2D6A3A0", Offset = "0x2D693A0", VA = "0x182D6A3A0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static int Min(int val1, int val2)
		{
			return 0;
		}

		/// <summary>Returns the smaller of two 32-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 32-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 32-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A7A RID: 2682 RVA: 0x000096D8 File Offset: 0x000078D8
		[Token(Token = "0x6000A7A")]
		[Address(RVA = "0x2D6A3C0", Offset = "0x2D693C0", VA = "0x182D6A3C0")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static uint Min(uint val1, uint val2)
		{
			return 0U;
		}

		/// <summary>Returns the smaller of two 64-bit signed integers.</summary>
		/// <param name="val1">The first of two 64-bit signed integers to compare.</param>
		/// <param name="val2">The second of two 64-bit signed integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A7B RID: 2683 RVA: 0x000096F0 File Offset: 0x000078F0
		[Token(Token = "0x6000A7B")]
		[Address(RVA = "0x2D6A280", Offset = "0x2D69280", VA = "0x182D6A280")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static long Min(long val1, long val2)
		{
			return 0L;
		}

		/// <summary>Returns the smaller of two 64-bit unsigned integers.</summary>
		/// <param name="val1">The first of two 64-bit unsigned integers to compare.</param>
		/// <param name="val2">The second of two 64-bit unsigned integers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A7C RID: 2684 RVA: 0x00009708 File Offset: 0x00007908
		[Token(Token = "0x6000A7C")]
		[Address(RVA = "0x2D6A3B0", Offset = "0x2D693B0", VA = "0x182D6A3B0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[CLSCompliant(false)]
		public static ulong Min(ulong val1, ulong val2)
		{
			return 0UL;
		}

		/// <summary>Returns the smaller of two single-precision floating-point numbers.</summary>
		/// <param name="val1">The first of two single-precision floating-point numbers to compare.</param>
		/// <param name="val2">The second of two single-precision floating-point numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Single.NaN" />, <see cref="F:System.Single.NaN" /> is returned.</returns>
		// Token: 0x06000A7D RID: 2685 RVA: 0x00009720 File Offset: 0x00007920
		[Token(Token = "0x6000A7D")]
		[Address(RVA = "0x2D6A2B0", Offset = "0x2D692B0", VA = "0x182D6A2B0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static float Min(float val1, float val2)
		{
			return 0f;
		}

		/// <summary>Returns the smaller of two double-precision floating-point numbers.</summary>
		/// <param name="val1">The first of two double-precision floating-point numbers to compare.</param>
		/// <param name="val2">The second of two double-precision floating-point numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller. If <paramref name="val1" />, <paramref name="val2" />, or both <paramref name="val1" /> and <paramref name="val2" /> are equal to <see cref="F:System.Double.NaN" />, <see cref="F:System.Double.NaN" /> is returned.</returns>
		// Token: 0x06000A7E RID: 2686 RVA: 0x00009738 File Offset: 0x00007938
		[Token(Token = "0x6000A7E")]
		[Address(RVA = "0x2D6A1E0", Offset = "0x2D691E0", VA = "0x182D6A1E0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static double Min(double val1, double val2)
		{
			return 0.0;
		}

		/// <summary>Returns the smaller of two decimal numbers.</summary>
		/// <param name="val1">The first of two decimal numbers to compare.</param>
		/// <param name="val2">The second of two decimal numbers to compare.</param>
		/// <returns>Parameter <paramref name="val1" /> or <paramref name="val2" />, whichever is smaller.</returns>
		// Token: 0x06000A7F RID: 2687 RVA: 0x00009750 File Offset: 0x00007950
		[Token(Token = "0x6000A7F")]
		[Address(RVA = "0x2D6A300", Offset = "0x2D69300", VA = "0x182D6A300")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static decimal Min(decimal val1, decimal val2)
		{
			return 0m;
		}

		/// <summary>Returns the logarithm of a specified number in a specified base.</summary>
		/// <param name="a">The number whose logarithm is to be found.</param>
		/// <param name="newBase">The base of the logarithm.</param>
		/// <returns>One of the values in the following table. (+Infinity denotes <see cref="F:System.Double.PositiveInfinity" />, -Infinity denotes <see cref="F:System.Double.NegativeInfinity" />, and NaN denotes <see cref="F:System.Double.NaN" />.)  
		///  <paramref name="a" /><paramref name="newBase" /> Return value  
		///
		///  <paramref name="a" />&gt; 0  
		///
		///   (0 &lt;<paramref name="newBase" />&lt; 1) -or-(<paramref name="newBase" />&gt; 1)  
		///
		///   lognewBase(a)  
		///
		///  <paramref name="a" />&lt; 0  
		///
		///   (any value)  
		///
		///   NaN  
		///
		///   (any value)  
		///
		///  <paramref name="newBase" />&lt; 0  
		///
		///   NaN  
		///
		///  <paramref name="a" /> != 1  
		///
		///  <paramref name="newBase" /> = 0  
		///
		///   NaN  
		///
		///  <paramref name="a" /> != 1  
		///
		///  <paramref name="newBase" /> = +Infinity  
		///
		///   NaN  
		///
		///  <paramref name="a" /> = NaN  
		///
		///   (any value)  
		///
		///   NaN  
		///
		///   (any value)  
		///
		///  <paramref name="newBase" /> = NaN  
		///
		///   NaN  
		///
		///   (any value)  
		///
		///  <paramref name="newBase" /> = 1  
		///
		///   NaN  
		///
		///  <paramref name="a" /> = 0  
		///
		///   0 &lt;<paramref name="newBase" />&lt; 1  
		///
		///   +Infinity  
		///
		///  <paramref name="a" /> = 0  
		///
		///  <paramref name="newBase" />&gt; 1  
		///
		///   -Infinity  
		///
		///  <paramref name="a" /> =  +Infinity  
		///
		///   0 &lt;<paramref name="newBase" />&lt; 1  
		///
		///   -Infinity  
		///
		///  <paramref name="a" /> =  +Infinity  
		///
		///  <paramref name="newBase" />&gt; 1  
		///
		///   +Infinity  
		///
		///  <paramref name="a" /> = 1  
		///
		///  <paramref name="newBase" /> = 0  
		///
		///   0  
		///
		///  <paramref name="a" /> = 1  
		///
		///  <paramref name="newBase" /> = +Infinity  
		///
		///   0</returns>
		// Token: 0x06000A80 RID: 2688 RVA: 0x00009768 File Offset: 0x00007968
		[Token(Token = "0x6000A80")]
		[Address(RVA = "0x2D69E70", Offset = "0x2D68E70", VA = "0x182D69E70")]
		public static double Log(double a, double newBase)
		{
			return 0.0;
		}

		/// <summary>Returns an integer that indicates the sign of a 32-bit signed integer.</summary>
		/// <param name="value">A signed number.</param>
		/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.  
		///   Return value  
		///
		///   Meaning  
		///
		///   -1  
		///
		///  <paramref name="value" /> is less than zero.  
		///
		///   0  
		///
		///  <paramref name="value" /> is equal to zero.  
		///
		///   1  
		///
		///  <paramref name="value" /> is greater than zero.</returns>
		// Token: 0x06000A81 RID: 2689 RVA: 0x00009780 File Offset: 0x00007980
		[Token(Token = "0x6000A81")]
		[Address(RVA = "0x2D6A790", Offset = "0x2D69790", VA = "0x182D6A790")]
		public static int Sign(int value)
		{
			return 0;
		}

		/// <summary>Returns an integer that indicates the sign of a 64-bit signed integer.</summary>
		/// <param name="value">A signed number.</param>
		/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.  
		///   Return value  
		///
		///   Meaning  
		///
		///   -1  
		///
		///  <paramref name="value" /> is less than zero.  
		///
		///   0  
		///
		///  <paramref name="value" /> is equal to zero.  
		///
		///   1  
		///
		///  <paramref name="value" /> is greater than zero.</returns>
		// Token: 0x06000A82 RID: 2690 RVA: 0x00009798 File Offset: 0x00007998
		[Token(Token = "0x6000A82")]
		[Address(RVA = "0x2D6A7B0", Offset = "0x2D697B0", VA = "0x182D6A7B0")]
		public static int Sign(long value)
		{
			return 0;
		}

		/// <summary>Returns an integer that indicates the sign of a double-precision floating-point number.</summary>
		/// <param name="value">A signed number.</param>
		/// <returns>A number that indicates the sign of <paramref name="value" />, as shown in the following table.  
		///   Return value  
		///
		///   Meaning  
		///
		///   -1  
		///
		///  <paramref name="value" /> is less than zero.  
		///
		///   0  
		///
		///  <paramref name="value" /> is equal to zero.  
		///
		///   1  
		///
		///  <paramref name="value" /> is greater than zero.</returns>
		/// <exception cref="T:System.ArithmeticException">
		///   <paramref name="value" /> is equal to <see cref="F:System.Double.NaN" />.</exception>
		// Token: 0x06000A83 RID: 2691 RVA: 0x000097B0 File Offset: 0x000079B0
		[Token(Token = "0x6000A83")]
		[Address(RVA = "0x2D6A6D0", Offset = "0x2D696D0", VA = "0x182D6A6D0")]
		public static int Sign(double value)
		{
			return 0;
		}

		// Token: 0x04000462 RID: 1122
		[Token(Token = "0x4000462")]
		private static double doubleRoundLimit;

		// Token: 0x04000463 RID: 1123
		[Token(Token = "0x4000463")]
		private const int maxRoundingDigits = 15;

		// Token: 0x04000464 RID: 1124
		[Token(Token = "0x4000464")]
		private static double[] roundPower10Double;

		/// <summary>Represents the ratio of the circumference of a circle to its diameter, specified by the constant, π.</summary>
		// Token: 0x04000465 RID: 1125
		[Token(Token = "0x4000465")]
		public const double PI = 3.141592653589793;

		/// <summary>Represents the natural logarithmic base, specified by the constant, <see langword="e" />.</summary>
		// Token: 0x04000466 RID: 1126
		[Token(Token = "0x4000466")]
		public const double E = 2.718281828459045;
	}
}