using System;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using Cpp2IlInjected;

namespace System
{
	/// <summary>Represents a globally unique identifier (GUID).</summary>
	// Token: 0x020000FC RID: 252
	[Token(Token = "0x20000FC")]
	[ComVisible(true)]
	[Serializable]
	public struct Guid : IFormattable, IComparable, IComparable<Guid>, IEquatable<Guid>
	{
		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure by using the specified array of bytes.</summary>
		/// <param name="b">A 16-element byte array containing values with which to initialize the GUID.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="b" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="b" /> is not 16 bytes long.</exception>
		// Token: 0x0600096B RID: 2411 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600096B")]
		[Address(RVA = "0x288E0B0", Offset = "0x288CEB0", VA = "0x18288E0B0")]
		public Guid(byte[] b)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure by using the specified unsigned integers and bytes.</summary>
		/// <param name="a">The first 4 bytes of the GUID.</param>
		/// <param name="b">The next 2 bytes of the GUID.</param>
		/// <param name="c">The next 2 bytes of the GUID.</param>
		/// <param name="d">The next byte of the GUID.</param>
		/// <param name="e">The next byte of the GUID.</param>
		/// <param name="f">The next byte of the GUID.</param>
		/// <param name="g">The next byte of the GUID.</param>
		/// <param name="h">The next byte of the GUID.</param>
		/// <param name="i">The next byte of the GUID.</param>
		/// <param name="j">The next byte of the GUID.</param>
		/// <param name="k">The next byte of the GUID.</param>
		// Token: 0x0600096C RID: 2412 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600096C")]
		[Address(RVA = "0x288E060", Offset = "0x288CE60", VA = "0x18288E060")]
		[CLSCompliant(false)]
		public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure by using the specified integers and byte array.</summary>
		/// <param name="a">The first 4 bytes of the GUID.</param>
		/// <param name="b">The next 2 bytes of the GUID.</param>
		/// <param name="c">The next 2 bytes of the GUID.</param>
		/// <param name="d">The remaining 8 bytes of the GUID.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="d" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.ArgumentException">
		///   <paramref name="d" /> is not 8 bytes long.</exception>
		// Token: 0x0600096D RID: 2413 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600096D")]
		[Address(RVA = "0x288E330", Offset = "0x288D130", VA = "0x18288E330")]
		public Guid(int a, short b, short c, byte[] d)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure by using the specified integers and bytes.</summary>
		/// <param name="a">The first 4 bytes of the GUID.</param>
		/// <param name="b">The next 2 bytes of the GUID.</param>
		/// <param name="c">The next 2 bytes of the GUID.</param>
		/// <param name="d">The next byte of the GUID.</param>
		/// <param name="e">The next byte of the GUID.</param>
		/// <param name="f">The next byte of the GUID.</param>
		/// <param name="g">The next byte of the GUID.</param>
		/// <param name="h">The next byte of the GUID.</param>
		/// <param name="i">The next byte of the GUID.</param>
		/// <param name="j">The next byte of the GUID.</param>
		/// <param name="k">The next byte of the GUID.</param>
		// Token: 0x0600096E RID: 2414 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600096E")]
		[Address(RVA = "0x288E060", Offset = "0x288CE60", VA = "0x18288E060")]
		public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k)
		{
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure by using the value represented by the specified string.</summary>
		/// <param name="g">A string that contains a GUID in one of the following formats ("d" represents a hexadecimal digit whose case is ignored):  
		///  32 contiguous digits:  
		///  dddddddddddddddddddddddddddddddd  
		///  -or-  
		///  Groups of 8, 4, 4, 4, and 12 digits with hyphens between the groups. The entire GUID can optionally be enclosed in matching braces or parentheses:  
		///  dddddddd-dddd-dddd-dddd-dddddddddddd  
		///  -or-  
		///  {dddddddd-dddd-dddd-dddd-dddddddddddd}  
		///  -or-  
		///  (dddddddd-dddd-dddd-dddd-dddddddddddd)  
		///  -or-  
		///  Groups of 8, 4, and 4 digits, and a subset of eight groups of 2 digits, with each group prefixed by "0x" or "0X", and separated by commas. The entire GUID, as well as the subset, is enclosed in matching braces:  
		///  {0xdddddddd, 0xdddd, 0xdddd,{0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd,0xdd}}  
		///  All braces, commas, and "0x" prefixes are required. All embedded spaces are ignored. All leading zeros in a group are ignored.  
		///  The digits shown in a group are the maximum number of meaningful digits that can appear in that group. You can specify from 1 to the number of digits shown for a group. The specified digits are assumed to be the low-order digits of the group.</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="g" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">The format of <paramref name="g" /> is invalid.</exception>
		/// <exception cref="T:System.OverflowException">The format of <paramref name="g" /> is invalid.</exception>
		// Token: 0x0600096F RID: 2415 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x600096F")]
		[Address(RVA = "0x288E570", Offset = "0x288D370", VA = "0x18288E570")]
		public Guid(string g)
		{
		}

		/// <summary>Converts the string representation of a GUID to the equivalent <see cref="T:System.Guid" /> structure.</summary>
		/// <param name="input">The string to convert.</param>
		/// <returns>A structure that contains the value that was parsed.</returns>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="input" /> is <see langword="null" />.</exception>
		/// <exception cref="T:System.FormatException">
		///   <paramref name="input" /> is not in a recognized format.</exception>
		// Token: 0x06000970 RID: 2416 RVA: 0x00008700 File Offset: 0x00006900
		[Token(Token = "0x6000970")]
		[Address(RVA = "0x288BC60", Offset = "0x288AA60", VA = "0x18288BC60")]
		public static Guid Parse(string input)
		{
			return default(Guid);
		}

		/// <summary>Converts the string representation of a GUID to the equivalent <see cref="T:System.Guid" /> structure.</summary>
		/// <param name="input">The GUID to convert.</param>
		/// <param name="result">The structure that will contain the parsed value. If the method returns <see langword="true" />, <paramref name="result" /> contains a valid <see cref="T:System.Guid" />. If the method returns <see langword="false" />, <paramref name="result" /> equals <see cref="F:System.Guid.Empty" />.</param>
		/// <returns>
		///   <see langword="true" /> if the parse operation was successful; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000971 RID: 2417 RVA: 0x00008718 File Offset: 0x00006918
		[Token(Token = "0x6000971")]
		[Address(RVA = "0x288DEC0", Offset = "0x288CCC0", VA = "0x18288DEC0")]
		public static bool TryParse(string input, out Guid result)
		{
			return default(bool);
		}

		// Token: 0x06000972 RID: 2418 RVA: 0x00008730 File Offset: 0x00006930
		[Token(Token = "0x6000972")]
		[Address(RVA = "0x288DC80", Offset = "0x288CA80", VA = "0x18288DC80")]
		private static bool TryParseGuid(string g, Guid.GuidStyles flags, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x06000973 RID: 2419 RVA: 0x00008748 File Offset: 0x00006948
		[Token(Token = "0x6000973")]
		[Address(RVA = "0x288D0D0", Offset = "0x288BED0", VA = "0x18288D0D0")]
		private static bool TryParseGuidWithHexPrefix(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x06000974 RID: 2420 RVA: 0x00008760 File Offset: 0x00006960
		[Token(Token = "0x6000974")]
		[Address(RVA = "0x288D830", Offset = "0x288C630", VA = "0x18288D830")]
		private static bool TryParseGuidWithNoStyle(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x06000975 RID: 2421 RVA: 0x00008778 File Offset: 0x00006978
		[Token(Token = "0x6000975")]
		[Address(RVA = "0x288CC20", Offset = "0x288BA20", VA = "0x18288CC20")]
		private static bool TryParseGuidWithDashes(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x06000976 RID: 2422 RVA: 0x00008790 File Offset: 0x00006990
		[Token(Token = "0x6000976")]
		[Address(RVA = "0x288C2B0", Offset = "0x288B0B0", VA = "0x18288C2B0")]
		private static bool StringToShort(string str, int requiredLength, int flags, out short result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x06000977 RID: 2423 RVA: 0x000087A8 File Offset: 0x000069A8
		[Token(Token = "0x6000977")]
		[Address(RVA = "0x288C1F0", Offset = "0x288AFF0", VA = "0x18288C1F0")]
		private unsafe static bool StringToShort(string str, int* parsePos, int requiredLength, int flags, out short result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x06000978 RID: 2424 RVA: 0x000087C0 File Offset: 0x000069C0
		[Token(Token = "0x6000978")]
		[Address(RVA = "0x288BDA0", Offset = "0x288ABA0", VA = "0x18288BDA0")]
		private static bool StringToInt(string str, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x06000979 RID: 2425 RVA: 0x000087D8 File Offset: 0x000069D8
		[Token(Token = "0x6000979")]
		[Address(RVA = "0x288BFA0", Offset = "0x288ADA0", VA = "0x18288BFA0")]
		private static bool StringToInt(string str, ref int parsePos, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x0600097A RID: 2426 RVA: 0x000087F0 File Offset: 0x000069F0
		[Token(Token = "0x600097A")]
		[Address(RVA = "0x288BE40", Offset = "0x288AC40", VA = "0x18288BE40")]
		private unsafe static bool StringToInt(string str, int* parsePos, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x0600097B RID: 2427 RVA: 0x00008808 File Offset: 0x00006A08
		[Token(Token = "0x600097B")]
		[Address(RVA = "0x288C030", Offset = "0x288AE30", VA = "0x18288C030")]
		private static bool StringToLong(string str, ref int parsePos, int flags, out long result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x0600097C RID: 2428 RVA: 0x00008820 File Offset: 0x00006A20
		[Token(Token = "0x600097C")]
		[Address(RVA = "0x288C0C0", Offset = "0x288AEC0", VA = "0x18288C0C0")]
		private unsafe static bool StringToLong(string str, int* parsePos, int flags, out long result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x0600097D RID: 2429 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600097D")]
		[Address(RVA = "0x288B380", Offset = "0x288A180", VA = "0x18288B380")]
		private static string EatAllWhitespace(string str)
		{
			return null;
		}

		// Token: 0x0600097E RID: 2430 RVA: 0x00008838 File Offset: 0x00006A38
		[Token(Token = "0x600097E")]
		[Address(RVA = "0x288B950", Offset = "0x288A750", VA = "0x18288B950")]
		private static bool IsHexPrefix(string str, int i)
		{
			return default(bool);
		}

		/// <summary>Returns a 16-element byte array that contains the value of this instance.</summary>
		/// <returns>A 16-element byte array.</returns>
		// Token: 0x0600097F RID: 2431 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600097F")]
		[Address(RVA = "0x288C3A0", Offset = "0x288B1A0", VA = "0x18288C3A0")]
		public byte[] ToByteArray()
		{
			return null;
		}

		/// <summary>Returns a string representation of the value of this instance in registry format.</summary>
		/// <returns>The value of this <see cref="T:System.Guid" />, formatted by using the "D" format specifier as follows:  
		///  xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx  
		///  where the value of the GUID is represented as a series of lowercase hexadecimal digits in groups of 8, 4, 4, 4, and 12 digits and separated by hyphens. An example of a return value is "382c74c3-721d-4f34-80e5-57657b6cbc27". To convert the hexadecimal digits from a through f to uppercase, call the <see cref="M:System.String.ToUpper" /> method on the returned string.</returns>
		// Token: 0x06000980 RID: 2432 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000980")]
		[Address(RVA = "0x288C610", Offset = "0x288B410", VA = "0x18288C610", Slot = "3")]
		public override string ToString()
		{
			return null;
		}

		/// <summary>Returns the hash code for this instance.</summary>
		/// <returns>The hash code for this instance.</returns>
		// Token: 0x06000981 RID: 2433 RVA: 0x00008850 File Offset: 0x00006A50
		[Token(Token = "0x6000981")]
		[Address(RVA = "0x288B6F0", Offset = "0x288A4F0", VA = "0x18288B6F0", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		/// <summary>Returns a value that indicates whether this instance is equal to a specified object.</summary>
		/// <param name="o">The object to compare with this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="o" /> is a <see cref="T:System.Guid" /> that has the same value as this instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000982 RID: 2434 RVA: 0x00008868 File Offset: 0x00006A68
		[Token(Token = "0x6000982")]
		[Address(RVA = "0x288B490", Offset = "0x288A290", VA = "0x18288B490", Slot = "0")]
		public override bool Equals(object o)
		{
			return default(bool);
		}

		/// <summary>Returns a value indicating whether this instance and a specified <see cref="T:System.Guid" /> object represent the same value.</summary>
		/// <param name="g">An object to compare to this instance.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="g" /> is equal to this instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000983 RID: 2435 RVA: 0x00008880 File Offset: 0x00006A80
		[Token(Token = "0x6000983")]
		[Address(RVA = "0x288B600", Offset = "0x288A400", VA = "0x18288B600", Slot = "7")]
		public bool Equals(Guid g)
		{
			return default(bool);
		}

		// Token: 0x06000984 RID: 2436 RVA: 0x00008898 File Offset: 0x00006A98
		[Token(Token = "0x6000984")]
		[Address(RVA = "0x288B720", Offset = "0x288A520", VA = "0x18288B720")]
		private int GetResult(uint me, uint them)
		{
			return 0;
		}

		/// <summary>Compares this instance to a specified object and returns an indication of their relative values.</summary>
		/// <param name="value">An object to compare, or <see langword="null" />.</param>
		/// <returns>A signed number indicating the relative values of this instance and <paramref name="value" />.  
		///   Return value  
		///
		///   Description  
		///
		///   A negative integer  
		///
		///   This instance is less than <paramref name="value" />.  
		///
		///   Zero  
		///
		///   This instance is equal to <paramref name="value" />.  
		///
		///   A positive integer  
		///
		///   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.Guid" />.</exception>
		// Token: 0x06000985 RID: 2437 RVA: 0x000088B0 File Offset: 0x00006AB0
		[Token(Token = "0x6000985")]
		[Address(RVA = "0x288AE80", Offset = "0x2889C80", VA = "0x18288AE80", Slot = "5")]
		public int CompareTo(object value)
		{
			return 0;
		}

		/// <summary>Compares this instance to a specified <see cref="T:System.Guid" /> object and returns an indication of their relative values.</summary>
		/// <param name="value">An object to compare to this instance.</param>
		/// <returns>A signed number indicating the relative values of this instance and <paramref name="value" />.  
		///   Return value  
		///
		///   Description  
		///
		///   A negative integer  
		///
		///   This instance is less than <paramref name="value" />.  
		///
		///   Zero  
		///
		///   This instance is equal to <paramref name="value" />.  
		///
		///   A positive integer  
		///
		///   This instance is greater than <paramref name="value" />.</returns>
		// Token: 0x06000986 RID: 2438 RVA: 0x000088C8 File Offset: 0x00006AC8
		[Token(Token = "0x6000986")]
		[Address(RVA = "0x288B140", Offset = "0x2889F40", VA = "0x18288B140", Slot = "6")]
		public int CompareTo(Guid value)
		{
			return 0;
		}

		/// <summary>Indicates whether the values of two specified <see cref="T:System.Guid" /> objects are equal.</summary>
		/// <param name="a">The first object to compare.</param>
		/// <param name="b">The second object to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="a" /> and <paramref name="b" /> are equal; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000987 RID: 2439 RVA: 0x000088E0 File Offset: 0x00006AE0
		[Token(Token = "0x6000987")]
		[Address(RVA = "0x288E6D0", Offset = "0x288D4D0", VA = "0x18288E6D0")]
		public static bool operator ==(Guid a, Guid b)
		{
			return default(bool);
		}

		/// <summary>Indicates whether the values of two specified <see cref="T:System.Guid" /> objects are not equal.</summary>
		/// <param name="a">The first object to compare.</param>
		/// <param name="b">The second object to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="a" /> and <paramref name="b" /> are not equal; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000988 RID: 2440 RVA: 0x000088F8 File Offset: 0x00006AF8
		[Token(Token = "0x6000988")]
		[Address(RVA = "0x288E850", Offset = "0x288D650", VA = "0x18288E850")]
		public static bool operator !=(Guid a, Guid b)
		{
			return default(bool);
		}

		/// <summary>Returns a string representation of the value of this <see cref="T:System.Guid" /> instance, according to the provided format specifier.</summary>
		/// <param name="format">A single format specifier that indicates how to format the value of this <see cref="T:System.Guid" />. The <paramref name="format" /> parameter can be "N", "D", "B", "P", or "X". If <paramref name="format" /> is <see langword="null" /> or an empty string (""), "D" is used.</param>
		/// <returns>The value of this <see cref="T:System.Guid" />, represented as a series of lowercase hexadecimal digits in the specified format.</returns>
		/// <exception cref="T:System.FormatException">The value of <paramref name="format" /> is not <see langword="null" />, an empty string (""), "N", "D", "B", "P", or "X".</exception>
		// Token: 0x06000989 RID: 2441 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000989")]
		[Address(RVA = "0x288CC10", Offset = "0x288BA10", VA = "0x18288CC10")]
		public string ToString(string format)
		{
			return null;
		}

		// Token: 0x0600098A RID: 2442 RVA: 0x00008910 File Offset: 0x00006B10
		[Token(Token = "0x600098A")]
		[Address(RVA = "0x288B740", Offset = "0x288A540", VA = "0x18288B740")]
		private static char HexToChar(int a)
		{
			return '\0';
		}

		// Token: 0x0600098B RID: 2443 RVA: 0x00008928 File Offset: 0x00006B28
		[Token(Token = "0x600098B")]
		[Address(RVA = "0x288B760", Offset = "0x288A560", VA = "0x18288B760")]
		private unsafe static int HexsToChars(char* guidChars, int offset, int a, int b)
		{
			return 0;
		}

		// Token: 0x0600098C RID: 2444 RVA: 0x00008940 File Offset: 0x00006B40
		[Token(Token = "0x600098C")]
		[Address(RVA = "0x288B7F0", Offset = "0x288A5F0", VA = "0x18288B7F0")]
		private unsafe static int HexsToChars(char* guidChars, int offset, int a, int b, bool hex)
		{
			return 0;
		}

		/// <summary>Returns a string representation of the value of this instance of the <see cref="T:System.Guid" /> class, according to the provided format specifier and culture-specific format information.</summary>
		/// <param name="format">A single format specifier that indicates how to format the value of this <see cref="T:System.Guid" />. The <paramref name="format" /> parameter can be "N", "D", "B", "P", or "X". If <paramref name="format" /> is <see langword="null" /> or an empty string (""), "D" is used.</param>
		/// <param name="provider">(Reserved) An object that supplies culture-specific formatting information.</param>
		/// <returns>The value of this <see cref="T:System.Guid" />, represented as a series of lowercase hexadecimal digits in the specified format.</returns>
		/// <exception cref="T:System.FormatException">The value of <paramref name="format" /> is not <see langword="null" />, an empty string (""), "N", "D", "B", "P", or "X".</exception>
		// Token: 0x0600098D RID: 2445 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x600098D")]
		[Address(RVA = "0x288C650", Offset = "0x288B450", VA = "0x18288C650", Slot = "4")]
		public string ToString(string format, IFormatProvider provider)
		{
			return null;
		}

		/// <summary>Initializes a new instance of the <see cref="T:System.Guid" /> structure.</summary>
		/// <returns>A new GUID object.</returns>
		// Token: 0x0600098E RID: 2446 RVA: 0x00008958 File Offset: 0x00006B58
		[Token(Token = "0x600098E")]
		[Address(RVA = "0x288BA40", Offset = "0x288A840", VA = "0x18288BA40")]
		public static Guid NewGuid()
		{
			return default(Guid);
		}

		/// <summary>A read-only instance of the <see cref="T:System.Guid" /> structure whose value is all zeros.</summary>
		// Token: 0x0400041E RID: 1054
		[Token(Token = "0x400041E")]
		public static readonly Guid Empty;

		// Token: 0x0400041F RID: 1055
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
		[Token(Token = "0x400041F")]
		private int _a;

		// Token: 0x04000420 RID: 1056
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
		[Token(Token = "0x4000420")]
		private short _b;

		// Token: 0x04000421 RID: 1057
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x6")]
		[Token(Token = "0x4000421")]
		private short _c;

		// Token: 0x04000422 RID: 1058
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
		[Token(Token = "0x4000422")]
		private byte _d;

		// Token: 0x04000423 RID: 1059
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x9")]
		[Token(Token = "0x4000423")]
		private byte _e;

		// Token: 0x04000424 RID: 1060
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA")]
		[Token(Token = "0x4000424")]
		private byte _f;

		// Token: 0x04000425 RID: 1061
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xB")]
		[Token(Token = "0x4000425")]
		private byte _g;

		// Token: 0x04000426 RID: 1062
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
		[Token(Token = "0x4000426")]
		private byte _h;

		// Token: 0x04000427 RID: 1063
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xD")]
		[Token(Token = "0x4000427")]
		private byte _i;

		// Token: 0x04000428 RID: 1064
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xE")]
		[Token(Token = "0x4000428")]
		private byte _j;

		// Token: 0x04000429 RID: 1065
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xF")]
		[Token(Token = "0x4000429")]
		private byte _k;

		// Token: 0x0400042A RID: 1066
		[Token(Token = "0x400042A")]
		private static object _rngAccess;

		// Token: 0x0400042B RID: 1067
		[Token(Token = "0x400042B")]
		private static RandomNumberGenerator _rng;

		// Token: 0x0400042C RID: 1068
		[Token(Token = "0x400042C")]
		private static RandomNumberGenerator _fastRng;

		// Token: 0x020000FD RID: 253
		[Token(Token = "0x20000FD")]
		[Flags]
		private enum GuidStyles
		{
			// Token: 0x0400042E RID: 1070
			[Token(Token = "0x400042E")]
			None = 0,
			// Token: 0x0400042F RID: 1071
			[Token(Token = "0x400042F")]
			AllowParenthesis = 1,
			// Token: 0x04000430 RID: 1072
			[Token(Token = "0x4000430")]
			AllowBraces = 2,
			// Token: 0x04000431 RID: 1073
			[Token(Token = "0x4000431")]
			AllowDashes = 4,
			// Token: 0x04000432 RID: 1074
			[Token(Token = "0x4000432")]
			AllowHexPrefix = 8,
			// Token: 0x04000433 RID: 1075
			[Token(Token = "0x4000433")]
			RequireParenthesis = 16,
			// Token: 0x04000434 RID: 1076
			[Token(Token = "0x4000434")]
			RequireBraces = 32,
			// Token: 0x04000435 RID: 1077
			[Token(Token = "0x4000435")]
			RequireDashes = 64,
			// Token: 0x04000436 RID: 1078
			[Token(Token = "0x4000436")]
			RequireHexPrefix = 128,
			// Token: 0x04000437 RID: 1079
			[Token(Token = "0x4000437")]
			HexFormat = 160,
			// Token: 0x04000438 RID: 1080
			[Token(Token = "0x4000438")]
			NumberFormat = 0,
			// Token: 0x04000439 RID: 1081
			[Token(Token = "0x4000439")]
			DigitFormat = 64,
			// Token: 0x0400043A RID: 1082
			[Token(Token = "0x400043A")]
			BraceFormat = 96,
			// Token: 0x0400043B RID: 1083
			[Token(Token = "0x400043B")]
			ParenthesisFormat = 80,
			// Token: 0x0400043C RID: 1084
			[Token(Token = "0x400043C")]
			Any = 15
		}

		// Token: 0x020000FE RID: 254
		[Token(Token = "0x20000FE")]
		private enum GuidParseThrowStyle
		{
			// Token: 0x0400043E RID: 1086
			[Token(Token = "0x400043E")]
			None,
			// Token: 0x0400043F RID: 1087
			[Token(Token = "0x400043F")]
			All,
			// Token: 0x04000440 RID: 1088
			[Token(Token = "0x4000440")]
			AllButOverflow
		}

		// Token: 0x020000FF RID: 255
		[Token(Token = "0x20000FF")]
		private enum ParseFailureKind
		{
			// Token: 0x04000442 RID: 1090
			[Token(Token = "0x4000442")]
			None,
			// Token: 0x04000443 RID: 1091
			[Token(Token = "0x4000443")]
			ArgumentNull,
			// Token: 0x04000444 RID: 1092
			[Token(Token = "0x4000444")]
			Format,
			// Token: 0x04000445 RID: 1093
			[Token(Token = "0x4000445")]
			FormatWithParameter,
			// Token: 0x04000446 RID: 1094
			[Token(Token = "0x4000446")]
			NativeException,
			// Token: 0x04000447 RID: 1095
			[Token(Token = "0x4000447")]
			FormatWithInnerException
		}

		// Token: 0x02000100 RID: 256
		[Token(Token = "0x2000100")]
		private struct GuidResult
		{
			// Token: 0x06000990 RID: 2448 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000990")]
			[Address(RVA = "0x288AC60", Offset = "0x2889A60", VA = "0x18288AC60")]
			internal void Init(Guid.GuidParseThrowStyle canThrow)
			{
			}

			// Token: 0x06000991 RID: 2449 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000991")]
			[Address(RVA = "0x288AE70", Offset = "0x2889C70", VA = "0x18288AE70")]
			internal void SetFailure(Exception nativeException)
			{
			}

			// Token: 0x06000992 RID: 2450 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000992")]
			[Address(RVA = "0x288AD60", Offset = "0x2889B60", VA = "0x18288AD60")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID)
			{
			}

			// Token: 0x06000993 RID: 2451 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000993")]
			[Address(RVA = "0x288ACD0", Offset = "0x2889AD0", VA = "0x18288ACD0")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument)
			{
			}

			// Token: 0x06000994 RID: 2452 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x6000994")]
			[Address(RVA = "0x288ADE0", Offset = "0x2889BE0", VA = "0x18288ADE0")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument, string failureArgumentName, Exception innerException)
			{
			}

			// Token: 0x06000995 RID: 2453 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x6000995")]
			[Address(RVA = "0x288AA90", Offset = "0x2889890", VA = "0x18288AA90")]
			internal Exception GetGuidParseException()
			{
				return null;
			}

			// Token: 0x04000448 RID: 1096
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000448")]
			internal Guid parsedGuid;

			// Token: 0x04000449 RID: 1097
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4000449")]
			internal Guid.GuidParseThrowStyle throwStyle;

			// Token: 0x0400044A RID: 1098
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x14")]
			[Token(Token = "0x400044A")]
			internal Guid.ParseFailureKind m_failure;

			// Token: 0x0400044B RID: 1099
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x400044B")]
			internal string m_failureMessageID;

			// Token: 0x0400044C RID: 1100
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x400044C")]
			internal object m_failureMessageFormatArgument;

			// Token: 0x0400044D RID: 1101
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x400044D")]
			internal string m_failureArgumentName;

			// Token: 0x0400044E RID: 1102
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x400044E")]
			internal Exception m_innerException;
		}
	}
}