using System;
using System.Collections;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using HG;
using IL.RoR2;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using On.RoR2;
using R2API.AutoVersionGen;
using RoR2;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.ProcType")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: AssemblyInformationalVersion("1.0.2+de906744166246d147865416a8acd4b143a0b856")]
[assembly: AssemblyProduct("R2API.ProcType")]
[assembly: AssemblyTitle("R2API.ProcType")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace R2API
{
	public enum ModdedProcType
	{
		Invalid
	}
	[AutoVersion]
	public static class ProcTypeAPI
	{
		private delegate bool ProcChainMask_AppendToStringBuilder_Delegate(ref ProcChainMask procChainMask, StringBuilder stringBuilder, bool flag);

		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__ProcChainMask_AppendToStringBuilder;

			public static hook_Write_NetworkWriter_ProcChainMask <1>__NetworkExtensions_Write_NetworkWriter_ProcChainMask;

			public static hook_ReadProcChainMask <2>__NetworkExtensions_ReadProcChainMask;

			public static hook_GetHashCode <3>__ProcChainMask_GetHashCode;

			public static hook_Equals_ProcChainMask <4>__ProcChainMask_Equals_ProcChainMask;
		}

		public const string PluginGUID = "com.bepis.r2api.proctype";

		public const string PluginName = "R2API.ProcType";

		private static bool _hookEnabled;

		private static int _moddedProcTypeCount;

		private static int byteCount;

		private static byte[] buffer;

		public const string PluginVersion = "1.0.2";

		public static int ModdedProcTypeCount
		{
			get
			{
				return _moddedProcTypeCount;
			}
			private set
			{
				if (_moddedProcTypeCount != value)
				{
					_moddedProcTypeCount = value;
					if (byteCount != (byteCount = value + 7 >> 3))
					{
						buffer = new byte[byteCount];
					}
				}
			}
		}

		public static ModdedProcType ReserveProcType()
		{
			SetHooks();
			if (ModdedProcTypeCount == int.MaxValue)
			{
				throw new IndexOutOfRangeException($"Reached the ModdedProcType limit ({int.MaxValue})! Please contact R2API developers to increase the limit");
			}
			ModdedProcTypeCount++;
			return (ModdedProcType)ModdedProcTypeCount;
		}

		public static void AddModdedProc(this ref ProcChainMask procChainMask, ModdedProcType procType)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (procType <= ModdedProcType.Invalid || (int)procType > ModdedProcTypeCount)
			{
				ProcTypePlugin.Logger.LogError((object)string.Format("Parameter '{0}' with value {1} is out of range of registered types (1-{2})\n{3}", "procType", procType, ModdedProcTypeCount, new StackTrace(fNeedFileInfo: true)));
				return;
			}
			SetHooks();
			procType--;
			byte[] moddedMask = ProcTypeInterop.GetModdedMask(procChainMask);
			int num = (int)procType >> 3;
			byte[] array;
			if (moddedMask == null)
			{
				array = new byte[num + 1];
				array[num] = GetMaskingBit(num, procType);
			}
			else if (moddedMask.Length > num)
			{
				byte b = (byte)(moddedMask[num] | GetMaskingBit(num, procType));
				if (b == moddedMask[num])
				{
					return;
				}
				array = ArrayUtils.Clone<byte>(moddedMask);
				array[num] = b;
			}
			else
			{
				array = moddedMask;
				Array.Resize(ref array, num + 1);
				array[num] = GetMaskingBit(num, procType);
			}
			ProcTypeInterop.SetModdedMask(ref procChainMask, array);
		}

		public static void RemoveModdedProc(this ref ProcChainMask procChainMask, ModdedProcType procType)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (procType <= ModdedProcType.Invalid || (int)procType > ModdedProcTypeCount)
			{
				ProcTypePlugin.Logger.LogError((object)string.Format("Parameter '{0}' with value {1} is out of range of registered types (1-{2})\n{3}", "procType", procType, ModdedProcTypeCount, new StackTrace(fNeedFileInfo: true)));
				return;
			}
			SetHooks();
			procType--;
			byte[] array = ProcTypeInterop.GetModdedMask(procChainMask);
			if (array == null)
			{
				return;
			}
			int num = (int)procType >> 3;
			if (array.Length <= num)
			{
				return;
			}
			byte b = (byte)(array[num] & ~GetMaskingBit(num, procType));
			if (b == array[num])
			{
				return;
			}
			if (b == 0 && array.Length == num + 1)
			{
				int num2 = 0;
				for (int num3 = array.Length - 2; num3 >= 0; num3--)
				{
					if (array[num3] != 0)
					{
						num2 = num3 + 1;
						break;
					}
				}
				if (num2 == 0)
				{
					array = null;
				}
				else
				{
					Array.Resize(ref array, num2);
				}
			}
			else
			{
				array = ArrayUtils.Clone<byte>(array);
				array[num] = b;
			}
			ProcTypeInterop.SetModdedMask(ref procChainMask, array);
		}

		public static bool HasModdedProc(this ProcChainMask procChainMask, ModdedProcType procType)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (procType <= ModdedProcType.Invalid || (int)procType > ModdedProcTypeCount)
			{
				ProcTypePlugin.Logger.LogError((object)string.Format("Parameter '{0}' with value {1} is out of range of registered types (1-{2})\n{3}", "procType", procType, ModdedProcTypeCount, new StackTrace(fNeedFileInfo: true)));
				return false;
			}
			procType--;
			byte[] moddedMask = ProcTypeInterop.GetModdedMask(procChainMask);
			if (moddedMask == null)
			{
				return false;
			}
			int num = (int)procType >> 3;
			if (moddedMask.Length > num)
			{
				return (moddedMask[num] & GetMaskingBit(num, procType)) > 0;
			}
			return false;
		}

		public static BitArray GetModdedMask(ProcChainMask procChainMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			BitArray moddedMaskRaw = GetModdedMaskRaw(procChainMask);
			moddedMaskRaw.Length = ModdedProcTypeCount;
			return moddedMaskRaw;
		}

		public static void GetModdedMask(ProcChainMask procChainMask, BitArray dest)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GetModdedMaskRaw(procChainMask, dest);
			dest.Length = ModdedProcTypeCount;
		}

		public static BitArray GetModdedMaskRaw(ProcChainMask procChainMask)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			SetHooks();
			byte[] moddedMask = ProcTypeInterop.GetModdedMask(procChainMask);
			if (moddedMask == null)
			{
				return new BitArray(0);
			}
			return new BitArray(moddedMask);
		}

		public static void GetModdedMaskRaw(ProcChainMask procChainMask, BitArray dest)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (dest == null)
			{
				throw new ArgumentNullException("dest");
			}
			SetHooks();
			byte[] moddedMask = ProcTypeInterop.GetModdedMask(procChainMask);
			if (moddedMask != null)
			{
				dest.Length = moddedMask.Length << 3;
				for (int i = 0; i < moddedMask.Length; i++)
				{
					byte b = moddedMask[i];
					int num = i << 3;
					dest[num] = (b & 1) > 0;
					dest[num + 1] = (b & 2) > 0;
					dest[num + 2] = (b & 4) > 0;
					dest[num + 3] = (b & 8) > 0;
					dest[num + 4] = (b & 0x10) > 0;
					dest[num + 5] = (b & 0x20) > 0;
					dest[num + 6] = (b & 0x40) > 0;
					dest[num + 7] = (b & 0x80) > 0;
				}
			}
			else
			{
				dest.Length = 0;
			}
		}

		public static void SetModdedMask(ref ProcChainMask procChainMask, BitArray value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			SetHooks();
			int num = 0;
			for (int num2 = value.Length - 1; num2 >= 0; num2--)
			{
				if (value[num2])
				{
					num = num2 + 7 >> 3;
					break;
				}
			}
			if (num > 0)
			{
				byte[] array = new byte[num];
				value.CopyTo(buffer, 0);
				Array.Copy(buffer, 0, array, 0, num);
				ProcTypeInterop.SetModdedMask(ref procChainMask, array);
			}
			else
			{
				ProcTypeInterop.SetModdedMask(ref procChainMask, (byte[])null);
			}
		}

		internal static void SetHooks()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			if (!_hookEnabled)
			{
				object obj = <>O.<0>__ProcChainMask_AppendToStringBuilder;
				if (obj == null)
				{
					Manipulator val = ProcChainMask_AppendToStringBuilder;
					<>O.<0>__ProcChainMask_AppendToStringBuilder = val;
					obj = (object)val;
				}
				ProcChainMask.AppendToStringBuilder += (Manipulator)obj;
				object obj2 = <>O.<1>__NetworkExtensions_Write_NetworkWriter_ProcChainMask;
				if (obj2 == null)
				{
					hook_Write_NetworkWriter_ProcChainMask val2 = NetworkExtensions_Write_NetworkWriter_ProcChainMask;
					<>O.<1>__NetworkExtensions_Write_NetworkWriter_ProcChainMask = val2;
					obj2 = (object)val2;
				}
				NetworkExtensions.Write_NetworkWriter_ProcChainMask += (hook_Write_NetworkWriter_ProcChainMask)obj2;
				object obj3 = <>O.<2>__NetworkExtensions_ReadProcChainMask;
				if (obj3 == null)
				{
					hook_ReadProcChainMask val3 = NetworkExtensions_ReadProcChainMask;
					<>O.<2>__NetworkExtensions_ReadProcChainMask = val3;
					obj3 = (object)val3;
				}
				NetworkExtensions.ReadProcChainMask += (hook_ReadProcChainMask)obj3;
				object obj4 = <>O.<3>__ProcChainMask_GetHashCode;
				if (obj4 == null)
				{
					hook_GetHashCode val4 = ProcChainMask_GetHashCode;
					<>O.<3>__ProcChainMask_GetHashCode = val4;
					obj4 = (object)val4;
				}
				ProcChainMask.GetHashCode += (hook_GetHashCode)obj4;
				object obj5 = <>O.<4>__ProcChainMask_Equals_ProcChainMask;
				if (obj5 == null)
				{
					hook_Equals_ProcChainMask val5 = ProcChainMask_Equals_ProcChainMask;
					<>O.<4>__ProcChainMask_Equals_ProcChainMask = val5;
					obj5 = (object)val5;
				}
				ProcChainMask.Equals_ProcChainMask += (hook_Equals_ProcChainMask)obj5;
				_hookEnabled = true;
			}
		}

		internal static void UnsetHooks()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			object obj = <>O.<0>__ProcChainMask_AppendToStringBuilder;
			if (obj == null)
			{
				Manipulator val = ProcChainMask_AppendToStringBuilder;
				<>O.<0>__ProcChainMask_AppendToStringBuilder = val;
				obj = (object)val;
			}
			ProcChainMask.AppendToStringBuilder -= (Manipulator)obj;
			object obj2 = <>O.<1>__NetworkExtensions_Write_NetworkWriter_ProcChainMask;
			if (obj2 == null)
			{
				hook_Write_NetworkWriter_ProcChainMask val2 = NetworkExtensions_Write_NetworkWriter_ProcChainMask;
				<>O.<1>__NetworkExtensions_Write_NetworkWriter_ProcChainMask = val2;
				obj2 = (object)val2;
			}
			NetworkExtensions.Write_NetworkWriter_ProcChainMask -= (hook_Write_NetworkWriter_ProcChainMask)obj2;
			object obj3 = <>O.<2>__NetworkExtensions_ReadProcChainMask;
			if (obj3 == null)
			{
				hook_ReadProcChainMask val3 = NetworkExtensions_ReadProcChainMask;
				<>O.<2>__NetworkExtensions_ReadProcChainMask = val3;
				obj3 = (object)val3;
			}
			NetworkExtensions.ReadProcChainMask -= (hook_ReadProcChainMask)obj3;
			object obj4 = <>O.<3>__ProcChainMask_GetHashCode;
			if (obj4 == null)
			{
				hook_GetHashCode val4 = ProcChainMask_GetHashCode;
				<>O.<3>__ProcChainMask_GetHashCode = val4;
				obj4 = (object)val4;
			}
			ProcChainMask.GetHashCode -= (hook_GetHashCode)obj4;
			object obj5 = <>O.<4>__ProcChainMask_Equals_ProcChainMask;
			if (obj5 == null)
			{
				hook_Equals_ProcChainMask val5 = ProcChainMask_Equals_ProcChainMask;
				<>O.<4>__ProcChainMask_Equals_ProcChainMask = val5;
				obj5 = (object)val5;
			}
			ProcChainMask.Equals_ProcChainMask -= (hook_Equals_ProcChainMask)obj5;
			_hookEnabled = false;
		}

		private static void ProcChainMask_AppendToStringBuilder(ILContext il)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			int locFlagIndex = -1;
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, ref locFlagIndex)
			}) && val.TryGotoNext((MoveType)1, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 1),
				(Instruction x) => ILPatternMatchingExt.MatchLdstr(x, ")"),
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<StringBuilder>(x, "Append")
			}))
			{
				val.Emit(OpCodes.Ldarg, 0);
				val.Emit(OpCodes.Ldarg, 1);
				val.Emit(OpCodes.Ldloc, locFlagIndex);
				val.EmitDelegate<ProcChainMask_AppendToStringBuilder_Delegate>((ProcChainMask_AppendToStringBuilder_Delegate)delegate(ref ProcChainMask procChainMask, StringBuilder stringBuilder, bool flag)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					byte[] moddedMask = ProcTypeInterop.GetModdedMask(procChainMask);
					if (moddedMask != null)
					{
						for (int i = 0; i < moddedMask.Length; i++)
						{
							for (int j = 0; j < 8; j++)
							{
								if ((moddedMask[i] & (1 << j)) > 0)
								{
									if (flag)
									{
										stringBuilder.Append("|");
									}
									stringBuilder.Append(string.Format("({0}){1}", "ModdedProcType", (i << 3) + j));
									flag = true;
								}
							}
						}
					}
					return flag;
				});
				val.Emit(OpCodes.Stloc, locFlagIndex);
			}
			else
			{
				ProcTypePlugin.Logger.LogError((object)"ProcTypeAPI.ProcChainMask_AppendToStringBuilder IL match failed.");
			}
		}

		private static void NetworkExtensions_Write_NetworkWriter_ProcChainMask(orig_Write_NetworkWriter_ProcChainMask orig, NetworkWriter writer, ProcChainMask procChainMask)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(writer, procChainMask);
			writer.NetworkWriteModdedMask(ProcTypeInterop.GetModdedMask(procChainMask));
		}

		private static ProcChainMask NetworkExtensions_ReadProcChainMask(orig_ReadProcChainMask orig, NetworkReader reader)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			ProcChainMask result = orig.Invoke(reader);
			ProcTypeInterop.SetModdedMask(ref result, NetworkReadModdedMask(reader));
			return result;
		}

		private static int ProcChainMask_GetHashCode(orig_GetHashCode orig, ref ProcChainMask self)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return (orig.Invoke(ref self) * 397) ^ ModdedMaskHashCode(ProcTypeInterop.GetModdedMask(self));
		}

		private static bool ProcChainMask_Equals_ProcChainMask(orig_Equals_ProcChainMask orig, ref ProcChainMask self, ProcChainMask other)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (orig.Invoke(ref self, other))
			{
				return ModdedMaskEquals(ProcTypeInterop.GetModdedMask(self), ProcTypeInterop.GetModdedMask(other));
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static byte GetMaskingBit(int maskIndex, ModdedProcType procType)
		{
			return (byte)(1 << (int)(procType - (maskIndex << 3)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void NetworkWriteModdedMask(this NetworkWriter writer, byte[] mask)
		{
			int num = ((mask != null) ? mask.Length : 0);
			if (ModdedProcTypeCount <= 255)
			{
				writer.Write((byte)num);
			}
			else if (ModdedProcTypeCount <= 65535)
			{
				writer.Write((ushort)num);
			}
			else
			{
				writer.Write(num);
			}
			if (num != 0)
			{
				writer.Write(mask, num);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static byte[] NetworkReadModdedMask(NetworkReader reader)
		{
			int moddedProcTypeCount = ModdedProcTypeCount;
			int num = ((moddedProcTypeCount <= 255) ? reader.ReadByte() : ((moddedProcTypeCount > 65535) ? reader.ReadInt32() : reader.ReadUInt16()));
			int num2 = num;
			if (num2 <= 0)
			{
				return null;
			}
			return reader.ReadBytes(num2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int ModdedMaskHashCode(byte[] mask)
		{
			int num = 0;
			if (mask != null)
			{
				for (int i = 0; i < mask.Length; i++)
				{
					num = HashCode.Combine(num, mask[i]);
				}
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool ModdedMaskEquals(byte[] a, byte[] b)
		{
			return ArrayUtils.SequenceEquals<byte>(a ?? Array.Empty<byte>(), b ?? Array.Empty<byte>());
		}
	}
	[BepInPlugin("com.bepis.r2api.proctype", "R2API.ProcType", "1.0.2")]
	public sealed class ProcTypePlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
		}

		private void OnDestroy()
		{
			ProcTypeAPI.UnsetHooks();
		}
	}
}
namespace R2API.AutoVersionGen
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal class AutoVersionAttribute : Attribute
	{
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Microsoft.CodeAnalysis;
using RoR2;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("R2API.ProcType")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.ProcType.Interop")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+de906744166246d147865416a8acd4b143a0b856")]
[assembly: AssemblyProduct("R2API.ProcType.Interop")]
[assembly: AssemblyTitle("R2API.ProcType.Interop")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace R2API
{
	internal static class ProcTypeInterop
	{
		public static byte[] GetModdedMask(ProcChainMask procChainMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return procChainMask.r2api_moddedMask;
		}

		public static void SetModdedMask(ref ProcChainMask procChainMask, byte[] value)
		{
			procChainMask.r2api_moddedMask = value;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Microsoft.CodeAnalysis;
using Mono.Cecil;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.ProcType.Patcher")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+de906744166246d147865416a8acd4b143a0b856")]
[assembly: AssemblyProduct("R2API.ProcType.Patcher")]
[assembly: AssemblyTitle("R2API.ProcType.Patcher")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace R2API
{
	internal static class ProcTypePatcher
	{
		public static IEnumerable<string> TargetDLLs
		{
			get
			{
				yield return "RoR2.dll";
			}
		}

		public static void Patch(AssemblyDefinition assembly)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			TypeDefinition type = assembly.MainModule.GetType("RoR2", "ProcChainMask");
			if (type != null)
			{
				type.Fields.Add(new FieldDefinition("r2api_moddedMask", (FieldAttributes)6, assembly.MainModule.ImportReference(typeof(byte[]))));
			}
		}
	}
}