using System;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using Cpp2IlInjected;

namespace System
{
	/// <summary>A platform-specific type that is used to represent a pointer or a handle.</summary>
	// Token: 0x0200017D RID: 381
	[Token(Token = "0x200017D")]
	[ComVisible(true)]
	[Serializable]
	public struct IntPtr : ISerializable
	{
		/// <summary>Initializes a new instance of <see cref="T:System.IntPtr" /> using the specified 32-bit pointer or handle.</summary>
		/// <param name="value">A pointer or handle contained in a 32-bit signed integer.</param>
		// Token: 0x06000F40 RID: 3904 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000F40")]
		[Address(RVA = "0x25FC070", Offset = "0x25FAE70", VA = "0x1825FC070")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public IntPtr(int value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.IntPtr" /> using the specified 64-bit pointer.</summary>
		/// <param name="value">A pointer or handle contained in a 64-bit signed integer.</param>
		/// <exception cref="T:System.OverflowException">On a 32-bit platform, <paramref name="value" /> is too large or too small to represent as an <see cref="T:System.IntPtr" />.</exception>
		// Token: 0x06000F41 RID: 3905 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000F41")]
		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public IntPtr(long value)
		{
		}

		/// <summary>Initializes a new instance of <see cref="T:System.IntPtr" /> using the specified pointer to an unspecified type.</summary>
		/// <param name="value">A pointer to an unspecified type.</param>
		// Token: 0x06000F42 RID: 3906 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000F42")]
		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		[CLSCompliant(false)]
		public unsafe IntPtr(void* value)
		{
		}

		// Token: 0x06000F43 RID: 3907 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000F43")]
		[Address(RVA = "0x25FC080", Offset = "0x25FAE80", VA = "0x1825FC080")]
		private IntPtr(SerializationInfo info, StreamingContext context)
		{
		}

		/// <summary>Gets the size of this instance.</summary>
		/// <returns>The size of a pointer or handle in this process, measured in bytes. The value of this property is 4 in a 32-bit process, and 8 in a 64-bit process. You can define the process type by setting the <see langword="/platform" /> switch when you compile your code with the C# and Visual Basic compilers.</returns>
		// Token: 0x1700016F RID: 367
		// (get) Token: 0x06000F44 RID: 3908 RVA: 0x0000C7B0 File Offset: 0x0000A9B0
		[Token(Token = "0x1700016F")]
		public static int Size
		{
			[Token(Token = "0x6000F44")]
			[Address(RVA = "0x4101D0", Offset = "0x40EFD0", VA = "0x1804101D0")]
			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
			get
			{
				return 0;
			}
		}

		/// <summary>Populates a <see cref="T:System.Runtime.Serialization.SerializationInfo" /> object with the data needed to serialize the current <see cref="T:System.IntPtr" /> object.</summary>
		/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> object to populate with data.</param>
		/// <param name="context">The destination for this serialization. (This parameter is not used; specify <see langword="null" />.)</param>
		/// <exception cref="T:System.ArgumentNullException">
		///   <paramref name="info" /> is <see langword="null" />.</exception>
		// Token: 0x06000F45 RID: 3909 RVA: 0x00002050 File Offset: 0x00000250
		[Token(Token = "0x6000F45")]
		[Address(RVA = "0x25FBF80", Offset = "0x25FAD80", VA = "0x1825FBF80", Slot = "4")]
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
		}

		/// <summary>Returns a value indicating whether this instance is equal to a specified object.</summary>
		/// <param name="obj">An object to compare with this instance or <see langword="null" />.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="obj" /> is an instance of <see cref="T:System.IntPtr" /> and equals the value of this instance; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000F46 RID: 3910 RVA: 0x0000C7C8 File Offset: 0x0000A9C8
		[Token(Token = "0x6000F46")]
		[Address(RVA = "0x25FBEF0", Offset = "0x25FACF0", VA = "0x1825FBEF0", Slot = "0")]
		public override bool Equals(object obj)
		{
			return default(bool);
		}

		/// <summary>Returns the hash code for this instance.</summary>
		/// <returns>A 32-bit signed integer hash code.</returns>
		// Token: 0x06000F47 RID: 3911 RVA: 0x0000C7E0 File Offset: 0x0000A9E0
		[Token(Token = "0x6000F47")]
		[Address(RVA = "0x57C620", Offset = "0x57B420", VA = "0x18057C620", Slot = "2")]
		public override int GetHashCode()
		{
			return 0;
		}

		/// <summary>Converts the value of this instance to a 64-bit signed integer.</summary>
		/// <returns>A 64-bit signed integer equal to the value of this instance.</returns>
		// Token: 0x06000F48 RID: 3912 RVA: 0x0000C7F8 File Offset: 0x0000A9F8
		[Token(Token = "0x6000F48")]
		[Address(RVA = "0x723160", Offset = "0x721F60", VA = "0x180723160")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public long ToInt64()
		{
			return 0L;
		}

		/// <summary>Converts the value of this instance to a pointer to an unspecified type.</summary>
		/// <returns>A pointer to <see cref="T:System.Void" />; that is, a pointer to memory containing data of an unspecified type.</returns>
		// Token: 0x06000F49 RID: 3913 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000F49")]
		[Address(RVA = "0x41D090", Offset = "0x41BE90", VA = "0x18041D090")]
		[CLSCompliant(false)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public unsafe void* ToPointer()
		{
			return null;
		}

		/// <summary>Converts the numeric value of the current <see cref="T:System.IntPtr" /> object to its equivalent string representation.</summary>
		/// <returns>The string representation of the value of this instance.</returns>
		// Token: 0x06000F4A RID: 3914 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000F4A")]
		[Address(RVA = "0x25FC000", Offset = "0x25FAE00", VA = "0x1825FC000", Slot = "3")]
		public override string ToString()
		{
			return null;
		}

		/// <summary>Converts the numeric value of the current <see cref="T:System.IntPtr" /> object to its equivalent string representation.</summary>
		/// <param name="format">A format specification that governs how the current <see cref="T:System.IntPtr" /> object is converted.</param>
		/// <returns>The string representation of the value of the current <see cref="T:System.IntPtr" /> object.</returns>
		// Token: 0x06000F4B RID: 3915 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000F4B")]
		[Address(RVA = "0x25FC030", Offset = "0x25FAE30", VA = "0x1825FC030")]
		public string ToString(string format)
		{
			return null;
		}

		/// <summary>Determines whether two specified instances of <see cref="T:System.IntPtr" /> are equal.</summary>
		/// <param name="value1">The first pointer or handle to compare.</param>
		/// <param name="value2">The second pointer or handle to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value1" /> equals <paramref name="value2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000F4C RID: 3916 RVA: 0x0000C810 File Offset: 0x0000AA10
		[Token(Token = "0x6000F4C")]
		[Address(RVA = "0x4C3A20", Offset = "0x4C2820", VA = "0x1804C3A20")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static bool operator ==(IntPtr value1, IntPtr value2)
		{
			return default(bool);
		}

		/// <summary>Determines whether two specified instances of <see cref="T:System.IntPtr" /> are not equal.</summary>
		/// <param name="value1">The first pointer or handle to compare.</param>
		/// <param name="value2">The second pointer or handle to compare.</param>
		/// <returns>
		///   <see langword="true" /> if <paramref name="value1" /> does not equal <paramref name="value2" />; otherwise, <see langword="false" />.</returns>
		// Token: 0x06000F4D RID: 3917 RVA: 0x0000C828 File Offset: 0x0000AA28
		[Token(Token = "0x6000F4D")]
		[Address(RVA = "0x164B260", Offset = "0x164A060", VA = "0x18164B260")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		public static bool operator !=(IntPtr value1, IntPtr value2)
		{
			return default(bool);
		}

		/// <summary>Converts the value of a 32-bit signed integer to an <see cref="T:System.IntPtr" />.</summary>
		/// <param name="value">A 32-bit signed integer.</param>
		/// <returns>A new instance of <see cref="T:System.IntPtr" /> initialized to <paramref name="value" />.</returns>
		// Token: 0x06000F4E RID: 3918 RVA: 0x0000C840 File Offset: 0x0000AA40
		[Token(Token = "0x6000F4E")]
		[Address(RVA = "0x253A7B0", Offset = "0x25395B0", VA = "0x18253A7B0")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public static explicit operator IntPtr(int value)
		{
			return 0;
		}

		/// <summary>Converts the value of a 64-bit signed integer to an <see cref="T:System.IntPtr" />.</summary>
		/// <param name="value">A 64-bit signed integer.</param>
		/// <returns>A new instance of <see cref="T:System.IntPtr" /> initialized to <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">On a 32-bit platform, <paramref name="value" /> is too large to represent as an <see cref="T:System.IntPtr" />.</exception>
		// Token: 0x06000F4F RID: 3919 RVA: 0x0000C858 File Offset: 0x0000AA58
		[Token(Token = "0x6000F4F")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public static explicit operator IntPtr(long value)
		{
			return 0;
		}

		/// <summary>Converts the specified pointer to an unspecified type to an <see cref="T:System.IntPtr" />.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">A pointer to an unspecified type.</param>
		/// <returns>A new instance of <see cref="T:System.IntPtr" /> initialized to <paramref name="value" />.</returns>
		// Token: 0x06000F50 RID: 3920 RVA: 0x0000C870 File Offset: 0x0000AA70
		[Token(Token = "0x6000F50")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		[CLSCompliant(false)]
		public unsafe static explicit operator IntPtr(void* value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.IntPtr" /> to a 32-bit signed integer.</summary>
		/// <param name="value">The pointer or handle to convert.</param>
		/// <returns>The contents of <paramref name="value" />.</returns>
		/// <exception cref="T:System.OverflowException">On a 64-bit platform, the value of <paramref name="value" /> is too large to represent as a 32-bit signed integer.</exception>
		// Token: 0x06000F51 RID: 3921 RVA: 0x0000C888 File Offset: 0x0000AA88
		[Token(Token = "0x6000F51")]
		[Address(RVA = "0x8DB900", Offset = "0x8DA700", VA = "0x1808DB900")]
		public static explicit operator int(IntPtr value)
		{
			return 0;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.IntPtr" /> to a 64-bit signed integer.</summary>
		/// <param name="value">The pointer or handle to convert.</param>
		/// <returns>The contents of <paramref name="value" />.</returns>
		// Token: 0x06000F52 RID: 3922 RVA: 0x0000C8A0 File Offset: 0x0000AAA0
		[Token(Token = "0x6000F52")]
		[Address(RVA = "0x731B80", Offset = "0x730980", VA = "0x180731B80")]
		public static explicit operator long(IntPtr value)
		{
			return 0L;
		}

		/// <summary>Converts the value of the specified <see cref="T:System.IntPtr" /> to a pointer to an unspecified type.  
		///  This API is not CLS-compliant.</summary>
		/// <param name="value">The pointer or handle to convert.</param>
		/// <returns>The contents of <paramref name="value" />.</returns>
		// Token: 0x06000F53 RID: 3923 RVA: 0x00002082 File Offset: 0x00000282
		[Token(Token = "0x6000F53")]
		[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0")]
		[CLSCompliant(false)]
		public unsafe static explicit operator void*(IntPtr value)
		{
			return null;
		}

		/// <summary>Adds an offset to the value of a pointer.</summary>
		/// <param name="pointer">The pointer to add the offset to.</param>
		/// <param name="offset">The offset to add.</param>
		/// <returns>A new pointer that reflects the addition of <paramref name="offset" /> to <paramref name="pointer" />.</returns>
		// Token: 0x06000F54 RID: 3924 RVA: 0x0000C8B8 File Offset: 0x0000AAB8
		[Token(Token = "0x6000F54")]
		[Address(RVA = "0x25FBEE0", Offset = "0x25FACE0", VA = "0x1825FBEE0")]
		[ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
		public static IntPtr Add(IntPtr pointer, int offset)
		{
			return 0;
		}

		// Token: 0x06000F55 RID: 3925 RVA: 0x0000C8D0 File Offset: 0x0000AAD0
		[Token(Token = "0x6000F55")]
		[Address(RVA = "0x1D79150", Offset = "0x1D77F50", VA = "0x181D79150")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		internal bool IsNull()
		{
			return default(bool);
		}

		// Token: 0x0400062F RID: 1583
		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
		[Token(Token = "0x400062F")]
		private unsafe void* m_value;

		/// <summary>A read-only field that represents a pointer or handle that has been initialized to zero.</summary>
		// Token: 0x04000630 RID: 1584
		[Token(Token = "0x4000630")]
		public static readonly IntPtr Zero;
	}
}