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

namespace System
{
	/// <summary>Represents a globally unique identifier (GUID).</summary>
	// Token: 0x02000103 RID: 259
	[Token(Token = "0x2000103")]
	[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: 0x06000995 RID: 2453 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000995")]
		[Address(RVA = "0x2BB6DB0", Offset = "0x2BB5DB0", VA = "0x182BB6DB0")]
		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: 0x06000996 RID: 2454 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000996")]
		[Address(RVA = "0x2BB6D60", Offset = "0x2BB5D60", VA = "0x182BB6D60")]
		[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: 0x06000997 RID: 2455 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000997")]
		[Address(RVA = "0x2BB7030", Offset = "0x2BB6030", VA = "0x182BB7030")]
		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: 0x06000998 RID: 2456 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000998")]
		[Address(RVA = "0x2BB6D60", Offset = "0x2BB5D60", VA = "0x182BB6D60")]
		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: 0x06000999 RID: 2457 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000999")]
		[Address(RVA = "0x2BB7270", Offset = "0x2BB6270", VA = "0x182BB7270")]
		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: 0x0600099A RID: 2458 RVA: 0x00008910 File Offset: 0x00006B10
		[Token(Token = "0x600099A")]
		[Address(RVA = "0x2BB4960", Offset = "0x2BB3960", VA = "0x182BB4960")]
		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: 0x0600099B RID: 2459 RVA: 0x00008928 File Offset: 0x00006B28
		[Token(Token = "0x600099B")]
		[Address(RVA = "0x2BB6BC0", Offset = "0x2BB5BC0", VA = "0x182BB6BC0")]
		public static bool TryParse(string input, out Guid result)
		{
			return default(bool);
		}

		// Token: 0x0600099C RID: 2460 RVA: 0x00008940 File Offset: 0x00006B40
		[Token(Token = "0x600099C")]
		[Address(RVA = "0x2BB6980", Offset = "0x2BB5980", VA = "0x182BB6980")]
		private static bool TryParseGuid(string g, Guid.GuidStyles flags, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x0600099D RID: 2461 RVA: 0x00008958 File Offset: 0x00006B58
		[Token(Token = "0x600099D")]
		[Address(RVA = "0x2BB5DD0", Offset = "0x2BB4DD0", VA = "0x182BB5DD0")]
		private static bool TryParseGuidWithHexPrefix(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x0600099E RID: 2462 RVA: 0x00008970 File Offset: 0x00006B70
		[Token(Token = "0x600099E")]
		[Address(RVA = "0x2BB6530", Offset = "0x2BB5530", VA = "0x182BB6530")]
		private static bool TryParseGuidWithNoStyle(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x0600099F RID: 2463 RVA: 0x00008988 File Offset: 0x00006B88
		[Token(Token = "0x600099F")]
		[Address(RVA = "0x2BB5920", Offset = "0x2BB4920", VA = "0x182BB5920")]
		private static bool TryParseGuidWithDashes(string guidString, ref Guid.GuidResult result)
		{
			return default(bool);
		}

		// Token: 0x060009A0 RID: 2464 RVA: 0x000089A0 File Offset: 0x00006BA0
		[Token(Token = "0x60009A0")]
		[Address(RVA = "0x2BB4FB0", Offset = "0x2BB3FB0", VA = "0x182BB4FB0")]
		private static bool StringToShort(string str, int requiredLength, int flags, out short result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A1 RID: 2465 RVA: 0x000089B8 File Offset: 0x00006BB8
		[Token(Token = "0x60009A1")]
		[Address(RVA = "0x2BB4EF0", Offset = "0x2BB3EF0", VA = "0x182BB4EF0")]
		private unsafe static bool StringToShort(string str, int* parsePos, int requiredLength, int flags, out short result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A2 RID: 2466 RVA: 0x000089D0 File Offset: 0x00006BD0
		[Token(Token = "0x60009A2")]
		[Address(RVA = "0x2BB4AA0", Offset = "0x2BB3AA0", VA = "0x182BB4AA0")]
		private static bool StringToInt(string str, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A3 RID: 2467 RVA: 0x000089E8 File Offset: 0x00006BE8
		[Token(Token = "0x60009A3")]
		[Address(RVA = "0x2BB4CA0", Offset = "0x2BB3CA0", VA = "0x182BB4CA0")]
		private static bool StringToInt(string str, ref int parsePos, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A4 RID: 2468 RVA: 0x00008A00 File Offset: 0x00006C00
		[Token(Token = "0x60009A4")]
		[Address(RVA = "0x2BB4B40", Offset = "0x2BB3B40", VA = "0x182BB4B40")]
		private unsafe static bool StringToInt(string str, int* parsePos, int requiredLength, int flags, out int result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A5 RID: 2469 RVA: 0x00008A18 File Offset: 0x00006C18
		[Token(Token = "0x60009A5")]
		[Address(RVA = "0x2BB4D30", Offset = "0x2BB3D30", VA = "0x182BB4D30")]
		private static bool StringToLong(string str, ref int parsePos, int flags, out long result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A6 RID: 2470 RVA: 0x00008A30 File Offset: 0x00006C30
		[Token(Token = "0x60009A6")]
		[Address(RVA = "0x2BB4DC0", Offset = "0x2BB3DC0", VA = "0x182BB4DC0")]
		private unsafe static bool StringToLong(string str, int* parsePos, int flags, out long result, ref Guid.GuidResult parseResult)
		{
			return default(bool);
		}

		// Token: 0x060009A7 RID: 2471 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60009A7")]
		[Address(RVA = "0x2BB4080", Offset = "0x2BB3080", VA = "0x182BB4080")]
		private static string EatAllWhitespace(string str)
		{
			return null;
		}

		// Token: 0x060009A8 RID: 2472 RVA: 0x00008A48 File Offset: 0x00006C48
		[Token(Token = "0x60009A8")]
		[Address(RVA = "0x2BB4650", Offset = "0x2BB3650", VA = "0x182BB4650")]
		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: 0x060009A9 RID: 2473 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60009A9")]
		[Address(RVA = "0x2BB50A0", Offset = "0x2BB40A0", VA = "0x182BB50A0")]
		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: 0x060009AA RID: 2474 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60009AA")]
		[Address(RVA = "0x2BB5310", Offset = "0x2BB4310", VA = "0x182BB5310", 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: 0x060009AB RID: 2475 RVA: 0x00008A60 File Offset: 0x00006C60
		[Token(Token = "0x60009AB")]
		[Address(RVA = "0x2BB43F0", Offset = "0x2BB33F0", VA = "0x182BB43F0", 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: 0x060009AC RID: 2476 RVA: 0x00008A78 File Offset: 0x00006C78
		[Token(Token = "0x60009AC")]
		[Address(RVA = "0x2BB4190", Offset = "0x2BB3190", VA = "0x182BB4190", 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: 0x060009AD RID: 2477 RVA: 0x00008A90 File Offset: 0x00006C90
		[Token(Token = "0x60009AD")]
		[Address(RVA = "0x2BB4300", Offset = "0x2BB3300", VA = "0x182BB4300", Slot = "7")]
		public bool Equals(Guid g)
		{
			return default(bool);
		}

		// Token: 0x060009AE RID: 2478 RVA: 0x00008AA8 File Offset: 0x00006CA8
		[Token(Token = "0x60009AE")]
		[Address(RVA = "0x2BB4420", Offset = "0x2BB3420", VA = "0x182BB4420")]
		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: 0x060009AF RID: 2479 RVA: 0x00008AC0 File Offset: 0x00006CC0
		[Token(Token = "0x60009AF")]
		[Address(RVA = "0x2BB3B80", Offset = "0x2BB2B80", VA = "0x182BB3B80", 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: 0x060009B0 RID: 2480 RVA: 0x00008AD8 File Offset: 0x00006CD8
		[Token(Token = "0x60009B0")]
		[Address(RVA = "0x2BB3E40", Offset = "0x2BB2E40", VA = "0x182BB3E40", 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: 0x060009B1 RID: 2481 RVA: 0x00008AF0 File Offset: 0x00006CF0
		[Token(Token = "0x60009B1")]
		[Address(RVA = "0x2BB73D0", Offset = "0x2BB63D0", VA = "0x182BB73D0")]
		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: 0x060009B2 RID: 2482 RVA: 0x00008B08 File Offset: 0x00006D08
		[Token(Token = "0x60009B2")]
		[Address(RVA = "0x2BB7550", Offset = "0x2BB6550", VA = "0x182BB7550")]
		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: 0x060009B3 RID: 2483 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60009B3")]
		[Address(RVA = "0x2BB5910", Offset = "0x2BB4910", VA = "0x182BB5910")]
		public string ToString(string format)
		{
			return null;
		}

		// Token: 0x060009B4 RID: 2484 RVA: 0x00008B20 File Offset: 0x00006D20
		[Token(Token = "0x60009B4")]
		[Address(RVA = "0x2BB4440", Offset = "0x2BB3440", VA = "0x182BB4440")]
		private static char HexToChar(int a)
		{
			return '\0';
		}

		// Token: 0x060009B5 RID: 2485 RVA: 0x00008B38 File Offset: 0x00006D38
		[Token(Token = "0x60009B5")]
		[Address(RVA = "0x2BB4460", Offset = "0x2BB3460", VA = "0x182BB4460")]
		private unsafe static int HexsToChars(char* guidChars, int offset, int a, int b)
		{
			return 0;
		}

		// Token: 0x060009B6 RID: 2486 RVA: 0x00008B50 File Offset: 0x00006D50
		[Token(Token = "0x60009B6")]
		[Address(RVA = "0x2BB44F0", Offset = "0x2BB34F0", VA = "0x182BB44F0")]
		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: 0x060009B7 RID: 2487 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x60009B7")]
		[Address(RVA = "0x2BB5350", Offset = "0x2BB4350", VA = "0x182BB5350", 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: 0x060009B8 RID: 2488 RVA: 0x00008B68 File Offset: 0x00006D68
		[Token(Token = "0x60009B8")]
		[Address(RVA = "0x2BB4740", Offset = "0x2BB3740", VA = "0x182BB4740")]
		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: 0x04000428 RID: 1064
		[Token(Token = "0x4000428")]
		public static readonly Guid Empty;

		// Token: 0x04000429 RID: 1065
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
		[Token(Token = "0x4000429")]
		private int _a;

		// Token: 0x0400042A RID: 1066
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
		[Token(Token = "0x400042A")]
		private short _b;

		// Token: 0x0400042B RID: 1067
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x6")]
		[Token(Token = "0x400042B")]
		private short _c;

		// Token: 0x0400042C RID: 1068
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
		[Token(Token = "0x400042C")]
		private byte _d;

		// Token: 0x0400042D RID: 1069
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x9")]
		[Token(Token = "0x400042D")]
		private byte _e;

		// Token: 0x0400042E RID: 1070
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA")]
		[Token(Token = "0x400042E")]
		private byte _f;

		// Token: 0x0400042F RID: 1071
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xB")]
		[Token(Token = "0x400042F")]
		private byte _g;

		// Token: 0x04000430 RID: 1072
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
		[Token(Token = "0x4000430")]
		private byte _h;

		// Token: 0x04000431 RID: 1073
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xD")]
		[Token(Token = "0x4000431")]
		private byte _i;

		// Token: 0x04000432 RID: 1074
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xE")]
		[Token(Token = "0x4000432")]
		private byte _j;

		// Token: 0x04000433 RID: 1075
		[global::Cpp2IlInjected.FieldOffset(Offset = "0xF")]
		[Token(Token = "0x4000433")]
		private byte _k;

		// Token: 0x04000434 RID: 1076
		[Token(Token = "0x4000434")]
		private static object _rngAccess;

		// Token: 0x04000435 RID: 1077
		[Token(Token = "0x4000435")]
		private static RandomNumberGenerator _rng;

		// Token: 0x04000436 RID: 1078
		[Token(Token = "0x4000436")]
		private static RandomNumberGenerator _fastRng;

		// Token: 0x02000104 RID: 260
		[Token(Token = "0x2000104")]
		[Flags]
		private enum GuidStyles
		{
			// Token: 0x04000438 RID: 1080
			[Token(Token = "0x4000438")]
			None = 0,
			// Token: 0x04000439 RID: 1081
			[Token(Token = "0x4000439")]
			AllowParenthesis = 1,
			// Token: 0x0400043A RID: 1082
			[Token(Token = "0x400043A")]
			AllowBraces = 2,
			// Token: 0x0400043B RID: 1083
			[Token(Token = "0x400043B")]
			AllowDashes = 4,
			// Token: 0x0400043C RID: 1084
			[Token(Token = "0x400043C")]
			AllowHexPrefix = 8,
			// Token: 0x0400043D RID: 1085
			[Token(Token = "0x400043D")]
			RequireParenthesis = 16,
			// Token: 0x0400043E RID: 1086
			[Token(Token = "0x400043E")]
			RequireBraces = 32,
			// Token: 0x0400043F RID: 1087
			[Token(Token = "0x400043F")]
			RequireDashes = 64,
			// Token: 0x04000440 RID: 1088
			[Token(Token = "0x4000440")]
			RequireHexPrefix = 128,
			// Token: 0x04000441 RID: 1089
			[Token(Token = "0x4000441")]
			HexFormat = 160,
			// Token: 0x04000442 RID: 1090
			[Token(Token = "0x4000442")]
			NumberFormat = 0,
			// Token: 0x04000443 RID: 1091
			[Token(Token = "0x4000443")]
			DigitFormat = 64,
			// Token: 0x04000444 RID: 1092
			[Token(Token = "0x4000444")]
			BraceFormat = 96,
			// Token: 0x04000445 RID: 1093
			[Token(Token = "0x4000445")]
			ParenthesisFormat = 80,
			// Token: 0x04000446 RID: 1094
			[Token(Token = "0x4000446")]
			Any = 15
		}

		// Token: 0x02000105 RID: 261
		[Token(Token = "0x2000105")]
		private enum GuidParseThrowStyle
		{
			// Token: 0x04000448 RID: 1096
			[Token(Token = "0x4000448")]
			None,
			// Token: 0x04000449 RID: 1097
			[Token(Token = "0x4000449")]
			All,
			// Token: 0x0400044A RID: 1098
			[Token(Token = "0x400044A")]
			AllButOverflow
		}

		// Token: 0x02000106 RID: 262
		[Token(Token = "0x2000106")]
		private enum ParseFailureKind
		{
			// Token: 0x0400044C RID: 1100
			[Token(Token = "0x400044C")]
			None,
			// Token: 0x0400044D RID: 1101
			[Token(Token = "0x400044D")]
			ArgumentNull,
			// Token: 0x0400044E RID: 1102
			[Token(Token = "0x400044E")]
			Format,
			// Token: 0x0400044F RID: 1103
			[Token(Token = "0x400044F")]
			FormatWithParameter,
			// Token: 0x04000450 RID: 1104
			[Token(Token = "0x4000450")]
			NativeException,
			// Token: 0x04000451 RID: 1105
			[Token(Token = "0x4000451")]
			FormatWithInnerException
		}

		// Token: 0x02000107 RID: 263
		[Token(Token = "0x2000107")]
		private struct GuidResult
		{
			// Token: 0x060009BA RID: 2490 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60009BA")]
			[Address(RVA = "0x2BB3960", Offset = "0x2BB2960", VA = "0x182BB3960")]
			internal void Init(Guid.GuidParseThrowStyle canThrow)
			{
			}

			// Token: 0x060009BB RID: 2491 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60009BB")]
			[Address(RVA = "0x2BB3B70", Offset = "0x2BB2B70", VA = "0x182BB3B70")]
			internal void SetFailure(Exception nativeException)
			{
			}

			// Token: 0x060009BC RID: 2492 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60009BC")]
			[Address(RVA = "0x2BB3A60", Offset = "0x2BB2A60", VA = "0x182BB3A60")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID)
			{
			}

			// Token: 0x060009BD RID: 2493 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60009BD")]
			[Address(RVA = "0x2BB39D0", Offset = "0x2BB29D0", VA = "0x182BB39D0")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument)
			{
			}

			// Token: 0x060009BE RID: 2494 RVA: 0x00002050 File Offset: 0x00000250
			[Token(Token = "0x60009BE")]
			[Address(RVA = "0x2BB3AE0", Offset = "0x2BB2AE0", VA = "0x182BB3AE0")]
			internal void SetFailure(Guid.ParseFailureKind failure, string failureMessageID, object failureMessageFormatArgument, string failureArgumentName, Exception innerException)
			{
			}

			// Token: 0x060009BF RID: 2495 RVA: 0x00002082 File Offset: 0x00000282
			[Token(Token = "0x60009BF")]
			[Address(RVA = "0x2BB3790", Offset = "0x2BB2790", VA = "0x182BB3790")]
			internal Exception GetGuidParseException()
			{
				return null;
			}

			// Token: 0x04000452 RID: 1106
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
			[Token(Token = "0x4000452")]
			internal Guid parsedGuid;

			// Token: 0x04000453 RID: 1107
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
			[Token(Token = "0x4000453")]
			internal Guid.GuidParseThrowStyle throwStyle;

			// Token: 0x04000454 RID: 1108
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x14")]
			[Token(Token = "0x4000454")]
			internal Guid.ParseFailureKind m_failure;

			// Token: 0x04000455 RID: 1109
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
			[Token(Token = "0x4000455")]
			internal string m_failureMessageID;

			// Token: 0x04000456 RID: 1110
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
			[Token(Token = "0x4000456")]
			internal object m_failureMessageFormatArgument;

			// Token: 0x04000457 RID: 1111
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
			[Token(Token = "0x4000457")]
			internal string m_failureArgumentName;

			// Token: 0x04000458 RID: 1112
			[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
			[Token(Token = "0x4000458")]
			internal Exception m_innerException;
		}
	}
}