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: 0x02000115 RID: 277
	[Token(Token = "0x2000115")]
	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: 0x06000A23 RID: 2595 RVA: 0x00009090 File Offset: 0x00007290
		[Token(Token = "0x6000A23")]
		[Address(RVA = "0x25FDBC0", Offset = "0x25FC9C0", VA = "0x1825FDBC0")]
		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: 0x06000A24 RID: 2596 RVA: 0x000090A8 File Offset: 0x000072A8
		[Token(Token = "0x6000A24")]
		[Address(RVA = "0x25FDBD0", Offset = "0x25FC9D0", VA = "0x1825FDBD0")]
		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: 0x06000A25 RID: 2597 RVA: 0x000090C0 File Offset: 0x000072C0
		[Token(Token = "0x6000A25")]
		[Address(RVA = "0x25FDBF0", Offset = "0x25FC9F0", VA = "0x1825FDBF0")]
		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: 0x06000A26 RID: 2598 RVA: 0x000090D8 File Offset: 0x000072D8
		[Token(Token = "0x6000A26")]
		[Address(RVA = "0x25FDBE0", Offset = "0x25FC9E0", VA = "0x1825FDBE0")]
		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: 0x06000A27 RID: 2599 RVA: 0x000090F0 File Offset: 0x000072F0
		[Token(Token = "0x6000A27")]
		[Address(RVA = "0x25FDC00", Offset = "0x25FCA00", VA = "0x1825FDC00")]
		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: 0x06000A28 RID: 2600 RVA: 0x00009108 File Offset: 0x00007308
		[Token(Token = "0x6000A28")]
		[Address(RVA = "0x25FDC10", Offset = "0x25FCA10", VA = "0x1825FDC10")]
		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: 0x06000A29 RID: 2601 RVA: 0x00009120 File Offset: 0x00007320
		[Token(Token = "0x6000A29")]
		[Address(RVA = "0x25FDC30", Offset = "0x25FCA30", VA = "0x1825FDC30")]
		public static double Floor(double d)
		{
			return 0.0;
		}

		// Token: 0x06000A2A RID: 2602 RVA: 0x00009138 File Offset: 0x00007338
		[Token(Token = "0x6000A2A")]
		[Address(RVA = "0x25FDEC0", Offset = "0x25FCCC0", VA = "0x1825FDEC0")]
		private static double InternalRound(double value, int digits, MidpointRounding mode)
		{
			return 0.0;
		}

		// Token: 0x06000A2B RID: 2603 RVA: 0x00009150 File Offset: 0x00007350
		[Token(Token = "0x6000A2B")]
		[Address(RVA = "0x25FE090", Offset = "0x25FCE90", VA = "0x1825FE090")]
		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: 0x06000A2C RID: 2604 RVA: 0x00009168 File Offset: 0x00007368
		[Token(Token = "0x6000A2C")]
		[Address(RVA = "0x25FE830", Offset = "0x25FD630", VA = "0x1825FE830")]
		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: 0x06000A2D RID: 2605 RVA: 0x00009180 File Offset: 0x00007380
		[Token(Token = "0x6000A2D")]
		[Address(RVA = "0x25FE860", Offset = "0x25FD660", VA = "0x1825FE860")]
		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: 0x06000A2E RID: 2606 RVA: 0x00009198 File Offset: 0x00007398
		[Token(Token = "0x6000A2E")]
		[Address(RVA = "0x25FE590", Offset = "0x25FD390", VA = "0x1825FE590")]
		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: 0x06000A2F RID: 2607 RVA: 0x000091B0 File Offset: 0x000073B0
		[Token(Token = "0x6000A2F")]
		[Address(RVA = "0x25FE4D0", Offset = "0x25FD2D0", VA = "0x1825FE4D0")]
		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: 0x06000A30 RID: 2608 RVA: 0x000091C8 File Offset: 0x000073C8
		[Token(Token = "0x6000A30")]
		[Address(RVA = "0x25FE5A0", Offset = "0x25FD3A0", VA = "0x1825FE5A0")]
		public static double Round(double value, int digits, MidpointRounding mode)
		{
			return 0.0;
		}

		// Token: 0x06000A31 RID: 2609 RVA: 0x000091E0 File Offset: 0x000073E0
		[Token(Token = "0x6000A31")]
		[Address(RVA = "0x25FE840", Offset = "0x25FD640", VA = "0x1825FE840")]
		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: 0x06000A32 RID: 2610 RVA: 0x000091F8 File Offset: 0x000073F8
		[Token(Token = "0x6000A32")]
		[Address(RVA = "0x25FE870", Offset = "0x25FD670", VA = "0x1825FE870")]
		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: 0x06000A33 RID: 2611 RVA: 0x00009210 File Offset: 0x00007410
		[Token(Token = "0x6000A33")]
		[Address(RVA = "0x25FE850", Offset = "0x25FD650", VA = "0x1825FE850")]
		[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: 0x06000A34 RID: 2612 RVA: 0x00009228 File Offset: 0x00007428
		[Token(Token = "0x6000A34")]
		[Address(RVA = "0x25FE260", Offset = "0x25FD060", VA = "0x1825FE260")]
		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: 0x06000A35 RID: 2613 RVA: 0x00009240 File Offset: 0x00007440
		[Token(Token = "0x6000A35")]
		[Address(RVA = "0x25FE0F0", Offset = "0x25FCEF0", VA = "0x1825FE0F0")]
		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: 0x06000A36 RID: 2614 RVA: 0x00009258 File Offset: 0x00007458
		[Token(Token = "0x6000A36")]
		[Address(RVA = "0x25FDC20", Offset = "0x25FCA20", VA = "0x1825FDC20")]
		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: 0x06000A37 RID: 2615 RVA: 0x00009270 File Offset: 0x00007470
		[Token(Token = "0x6000A37")]
		[Address(RVA = "0x25FE4C0", Offset = "0x25FD2C0", VA = "0x1825FE4C0")]
		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: 0x06000A38 RID: 2616 RVA: 0x00009288 File Offset: 0x00007488
		[Token(Token = "0x6000A38")]
		[Address(RVA = "0x25FDC40", Offset = "0x25FCA40", VA = "0x1825FDC40")]
		public static double IEEERemainder(double x, double y)
		{
			return 0.0;
		}

		/// <summary>Returns the absolute value of a 16-bit signed integer.</summary>
		/// <param name="value">A number that is greater than <see cref="F:System.Int16.MinValue" />, but less than or equal to <see cref="F:System.Int16.MaxValue" />.</param>
		/// <returns>A 16-bit signed integer, x, such that 0 ≤ x ≤<see cref="F:System.Int16.MaxValue" />.</returns>
		/// <exception cref="T:System.OverflowException">
		///   <paramref name="value" /> equals <see cref="F:System.Int16.MinValue" />.</exception>
		// Token: 0x06000A39 RID: 2617 RVA: 0x000092A0 File Offset: 0x000074A0
		[Token(Token = "0x6000A39")]
		[Address(RVA = "0x25FD930", Offset = "0x25FC730", VA = "0x1825FD930")]
		public static short Abs(short value)
		{
			return 0;
		}

		// Token: 0x06000A3A RID: 2618 RVA: 0x000092B8 File Offset: 0x000074B8
		[Token(Token = "0x6000A3A")]
		[Address(RVA = "0x25FD7A0", Offset = "0x25FC5A0", VA = "0x1825FD7A0")]
		private static short AbsHelper(short value)
		{
			return 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: 0x06000A3B RID: 2619 RVA: 0x000092D0 File Offset: 0x000074D0
		[Token(Token = "0x6000A3B")]
		[Address(RVA = "0x25FDAE0", Offset = "0x25FC8E0", VA = "0x1825FDAE0")]
		public static int Abs(int value)
		{
			return 0;
		}

		// Token: 0x06000A3C RID: 2620 RVA: 0x000092E8 File Offset: 0x000074E8
		[Token(Token = "0x6000A3C")]
		[Address(RVA = "0x25FD8B0", Offset = "0x25FC6B0", VA = "0x1825FD8B0")]
		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: 0x06000A3D RID: 2621 RVA: 0x00009300 File Offset: 0x00007500
		[Token(Token = "0x6000A3D")]
		[Address(RVA = "0x25FDA00", Offset = "0x25FC800", VA = "0x1825FDA00")]
		public static long Abs(long value)
		{
			return 0L;
		}

		// Token: 0x06000A3E RID: 2622 RVA: 0x00009318 File Offset: 0x00007518
		[Token(Token = "0x6000A3E")]
		[Address(RVA = "0x25FD820", Offset = "0x25FC620", VA = "0x1825FD820")]
		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: 0x06000A3F RID: 2623 RVA: 0x00009330 File Offset: 0x00007530
		[Token(Token = "0x6000A3F")]
		[Address(RVA = "0x25FDBA0", Offset = "0x25FC9A0", VA = "0x1825FDBA0")]
		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: 0x06000A40 RID: 2624 RVA: 0x00009348 File Offset: 0x00007548
		[Token(Token = "0x6000A40")]
		[Address(RVA = "0x25FDAD0", Offset = "0x25FC8D0", VA = "0x1825FDAD0")]
		public static double Abs(double value)
		{
			return 0.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: 0x06000A41 RID: 2625 RVA: 0x00009360 File Offset: 0x00007560
		[Token(Token = "0x6000A41")]
		[Address(RVA = "0x25FE280", Offset = "0x25FD080", VA = "0x1825FE280")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static byte Max(byte val1, byte 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: 0x06000A42 RID: 2626 RVA: 0x00009378 File Offset: 0x00007578
		[Token(Token = "0x6000A42")]
		[Address(RVA = "0x25FE2A0", Offset = "0x25FD0A0", VA = "0x1825FE2A0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[CLSCompliant(false)]
		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: 0x06000A43 RID: 2627 RVA: 0x00009390 File Offset: 0x00007590
		[Token(Token = "0x6000A43")]
		[Address(RVA = "0x25FE300", Offset = "0x25FD100", VA = "0x1825FE300")]
		[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: 0x06000A44 RID: 2628 RVA: 0x000093A8 File Offset: 0x000075A8
		[Token(Token = "0x6000A44")]
		[Address(RVA = "0x25FE290", Offset = "0x25FD090", VA = "0x1825FE290")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[CLSCompliant(false)]
		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: 0x06000A45 RID: 2629 RVA: 0x000093C0 File Offset: 0x000075C0
		[Token(Token = "0x6000A45")]
		[Address(RVA = "0x25FE270", Offset = "0x25FD070", VA = "0x1825FE270")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static long Max(long val1, long val2)
		{
			return 0L;
		}

		/// <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: 0x06000A46 RID: 2630 RVA: 0x000093D8 File Offset: 0x000075D8
		[Token(Token = "0x6000A46")]
		[Address(RVA = "0x25FE2B0", Offset = "0x25FD0B0", VA = "0x1825FE2B0")]
		[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: 0x06000A47 RID: 2631 RVA: 0x000093F0 File Offset: 0x000075F0
		[Token(Token = "0x6000A47")]
		[Address(RVA = "0x25FE310", Offset = "0x25FD110", VA = "0x1825FE310")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static double Max(double val1, double val2)
		{
			return 0.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: 0x06000A48 RID: 2632 RVA: 0x00009408 File Offset: 0x00007608
		[Token(Token = "0x6000A48")]
		[Address(RVA = "0x25FE490", Offset = "0x25FD290", VA = "0x1825FE490")]
		[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: 0x06000A49 RID: 2633 RVA: 0x00009420 File Offset: 0x00007620
		[Token(Token = "0x6000A49")]
		[Address(RVA = "0x25FE4B0", Offset = "0x25FD2B0", VA = "0x1825FE4B0")]
		[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: 0x06000A4A RID: 2634 RVA: 0x00009438 File Offset: 0x00007638
		[Token(Token = "0x6000A4A")]
		[Address(RVA = "0x25FE430", Offset = "0x25FD230", VA = "0x1825FE430")]
		[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: 0x06000A4B RID: 2635 RVA: 0x00009450 File Offset: 0x00007650
		[Token(Token = "0x6000A4B")]
		[Address(RVA = "0x25FE4A0", Offset = "0x25FD2A0", VA = "0x1825FE4A0")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		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: 0x06000A4C RID: 2636 RVA: 0x00009468 File Offset: 0x00007668
		[Token(Token = "0x6000A4C")]
		[Address(RVA = "0x25FE440", Offset = "0x25FD240", VA = "0x1825FE440")]
		[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: 0x06000A4D RID: 2637 RVA: 0x00009480 File Offset: 0x00007680
		[Token(Token = "0x6000A4D")]
		[Address(RVA = "0x25FE3A0", Offset = "0x25FD1A0", VA = "0x1825FE3A0")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static double Min(double val1, double val2)
		{
			return 0.0;
		}

		/// <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: 0x06000A4E RID: 2638 RVA: 0x00009498 File Offset: 0x00007698
		[Token(Token = "0x6000A4E")]
		[Address(RVA = "0x25FE100", Offset = "0x25FCF00", VA = "0x1825FE100")]
		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: 0x06000A4F RID: 2639 RVA: 0x000094B0 File Offset: 0x000076B0
		[Token(Token = "0x6000A4F")]
		[Address(RVA = "0x25FE7F0", Offset = "0x25FD5F0", VA = "0x1825FE7F0")]
		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: 0x06000A50 RID: 2640 RVA: 0x000094C8 File Offset: 0x000076C8
		[Token(Token = "0x6000A50")]
		[Address(RVA = "0x25FE810", Offset = "0x25FD610", VA = "0x1825FE810")]
		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: 0x06000A51 RID: 2641 RVA: 0x000094E0 File Offset: 0x000076E0
		[Token(Token = "0x6000A51")]
		[Address(RVA = "0x25FE730", Offset = "0x25FD530", VA = "0x1825FE730")]
		public static int Sign(double value)
		{
			return 0;
		}

		// Token: 0x04000458 RID: 1112
		[Token(Token = "0x4000458")]
		private static double doubleRoundLimit;

		// Token: 0x04000459 RID: 1113
		[Token(Token = "0x4000459")]
		private const int maxRoundingDigits = 15;

		// Token: 0x0400045A RID: 1114
		[Token(Token = "0x400045A")]
		private static double[] roundPower10Double;

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

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