using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
public static class Patcher
{
	private static ManualLogSource log;

	public static IEnumerable<string> TargetDLLs => new string[0];

	public static void Patch(AssemblyDefinition ignored)
	{
	}

	public static void Initialize()
	{
		Apply(Path.GetDirectoryName(typeof(Patcher).Assembly.Location), Paths.PluginPath);
	}

	public static void Apply(string own, string plugins)
	{
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Expected O, but got Unknown
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Expected O, but got Unknown
		log = Logger.CreateLogSource("Parlay Compatibility Installer");
		string[] array = File.ReadAllLines(Path.Combine(own, "compatibility-rules.tsv"));
		foreach (string text in array)
		{
			if (string.IsNullOrWhiteSpace(text) || text.StartsWith("#"))
			{
				continue;
			}
			string[] array2 = text.Split('\t');
			if (array2.Length != 4)
			{
				throw new InvalidDataException("Invalid compatibility rule");
			}
			string[] files = Directory.GetFiles(plugins, array2[1], SearchOption.AllDirectories);
			string[] array3 = files;
			foreach (string text2 in array3)
			{
				string text3;
				using (SHA256 sHA = SHA256.Create())
				{
					using FileStream inputStream = File.OpenRead(text2);
					text3 = BitConverter.ToString(sHA.ComputeHash(inputStream)).Replace("-", "");
				}
				string path = text2 + ".parlay-patch-source";
				if (File.Exists(path) && File.ReadAllText(path).Trim() == text3)
				{
					continue;
				}
				if (text3 != array2[2])
				{
					log.LogWarning((object)("Unreviewed " + array2[1] + "; compatibility change skipped. Recheck its official update."));
					continue;
				}
				DefaultAssemblyResolver val = new DefaultAssemblyResolver();
				((BaseAssemblyResolver)val).AddSearchDirectory(Paths.ManagedPath);
				((BaseAssemblyResolver)val).AddSearchDirectory(Paths.BepInExRootPath + "/core");
				string[] directories = Directory.GetDirectories(plugins, "*", SearchOption.AllDirectories);
				foreach (string text4 in directories)
				{
					((BaseAssemblyResolver)val).AddSearchDirectory(text4);
				}
				AssemblyDefinition val2 = AssemblyDefinition.ReadAssembly(text2, new ReaderParameters
				{
					AssemblyResolver = (IAssemblyResolver)(object)val,
					InMemory = true
				});
				try
				{
					Transform(val2, array2[0]);
					string text5 = text2 + ".parlay-new";
					val2.Write(text5);
					if (!File.Exists(text2 + ".parlay-original"))
					{
						File.Copy(text2, text2 + ".parlay-original");
					}
					File.Copy(text5, text2, overwrite: true);
					File.Delete(text5);
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
				using (SHA256 sHA2 = SHA256.Create())
				{
					using FileStream inputStream2 = File.OpenRead(text2);
					File.WriteAllText(path, BitConverter.ToString(sHA2.ComputeHash(inputStream2)).Replace("-", ""));
				}
				log.LogInfo((object)("Applied reviewed compatibility change: " + array2[0] + " to " + array2[1]));
			}
		}
	}

	private static IEnumerable<MethodDefinition> Methods(ModuleDefinition m)
	{
		return m.GetTypes().SelectMany((TypeDefinition t) => (IEnumerable<MethodDefinition>)t.Methods);
	}

	private static MethodReference Method(TypeReference t, string name, TypeReference ret, params TypeReference[] args)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected O, but got Unknown
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		MethodReference val = new MethodReference(name, ret, t);
		foreach (TypeReference val2 in args)
		{
			val.Parameters.Add(new ParameterDefinition(val2));
		}
		return val;
	}

	public static void Transform(AssemblyDefinition a, string rule)
	{
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Invalid comparison between Unknown and I4
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a9b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aa2: Expected O, but got Unknown
		//IL_0aaf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ab6: Expected O, but got Unknown
		//IL_0ac3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aca: Expected O, but got Unknown
		//IL_0ad7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ade: Expected O, but got Unknown
		//IL_0bea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bf6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c04: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c0b: Expected O, but got Unknown
		//IL_0c2f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c3e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c4b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c5a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c69: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c78: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c87: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c96: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ca5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cb4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cc6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cd5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ce4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cf3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d02: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d11: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d23: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d32: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d49: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d60: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e9: Expected O, but got Unknown
		//IL_0404: Unknown result type (might be due to invalid IL or missing references)
		//IL_040b: Expected O, but got Unknown
		//IL_0414: Unknown result type (might be due to invalid IL or missing references)
		//IL_043a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0756: Unknown result type (might be due to invalid IL or missing references)
		//IL_075b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0611: Unknown result type (might be due to invalid IL or missing references)
		//IL_0633: Unknown result type (might be due to invalid IL or missing references)
		//IL_0919: Unknown result type (might be due to invalid IL or missing references)
		//IL_0929: Unknown result type (might be due to invalid IL or missing references)
		//IL_0945: Unknown result type (might be due to invalid IL or missing references)
		//IL_0954: Unknown result type (might be due to invalid IL or missing references)
		//IL_0961: Unknown result type (might be due to invalid IL or missing references)
		//IL_096e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		ModuleDefinition mainModule = a.MainModule;
		int num = 0;
		foreach (MethodDefinition item in from x in Methods(mainModule)
			where x.HasBody
			select x)
		{
			Enumerator<Instruction> enumerator2 = item.Body.Instructions.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					Instruction current2 = enumerator2.Current;
					OpCode opCode = current2.OpCode;
					if ((int)((OpCode)(ref opCode)).OperandType != 15)
					{
						continue;
					}
					opCode = current2.OpCode;
					string name = ((OpCode)(ref opCode)).Name;
					opCode = current2.OpCode;
					string longName = name.Substring(0, ((OpCode)(ref opCode)).Name.Length - 2);
					current2.OpCode = (OpCode)typeof(OpCodes).GetFields().Single(delegate(FieldInfo f)
					{
						//IL_001e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0023: Unknown result type (might be due to invalid IL or missing references)
						int result;
						if (f.FieldType == typeof(OpCode))
						{
							OpCode val29 = (OpCode)f.GetValue(null);
							result = ((((OpCode)(ref val29)).Name == longName) ? 1 : 0);
						}
						else
						{
							result = 0;
						}
						return (byte)result != 0;
					}).GetValue(null);
				}
			}
			finally
			{
				((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
		}
		switch (rule)
		{
		case "operator-invisibility":
			foreach (MethodDefinition item2 in from m in Methods(mainModule)
				where m.HasBody
				select m)
			{
				Enumerator<Instruction> enumerator9 = item2.Body.Instructions.GetEnumerator();
				try
				{
					while (enumerator9.MoveNext())
					{
						Instruction current9 = enumerator9.Current;
						object operand5 = current9.Operand;
						FieldReference val22 = (FieldReference)((operand5 is FieldReference) ? operand5 : null);
						if (val22 != null && !(((MemberReference)((MemberReference)val22).DeclaringType).FullName != "RoR2.CharacterModel") && !(((MemberReference)val22).Name != "invisibilityCount"))
						{
							bool flag = current9.OpCode == OpCodes.Stfld;
							if (!flag && current9.OpCode != OpCodes.Ldfld)
							{
								throw new InvalidDataException("Unexpected invisibility opcode");
							}
							MethodReference val23 = Method(((MemberReference)val22).DeclaringType, flag ? "set_invisibilityCount" : "get_invisibilityCount", flag ? mainModule.TypeSystem.Void : val22.FieldType, (TypeReference[])(object)((!flag) ? new TypeReference[0] : new TypeReference[1] { val22.FieldType }));
							val23.HasThis = true;
							current9.OpCode = OpCodes.Callvirt;
							current9.Operand = val23;
							num++;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator9/*cast due to .constrained prefix*/).Dispose();
				}
			}
			Require(num == 5, rule);
			break;
		case "command-icons":
			foreach (MethodDefinition item3 in from m in Methods(mainModule)
				where m.HasBody
				select m)
			{
				Collection<Instruction> instructions = item3.Body.Instructions;
				for (int num2 = 0; num2 < instructions.Count - 1; num2++)
				{
					object operand = instructions[num2].Operand;
					FieldReference val14 = (FieldReference)((operand is FieldReference) ? operand : null);
					object operand2 = instructions[num2 + 1].Operand;
					MethodReference val15 = (MethodReference)((operand2 is MethodReference) ? operand2 : null);
					if (val14 != null && !(((MemberReference)((MemberReference)val14).DeclaringType).FullName != "RoR2.PickupDef") && !(((MemberReference)val14).Name != "iconSprite") && val15 != null && !(((MemberReference)val15).Name != "set_sprite"))
					{
						AssemblyNameReference val16 = new AssemblyNameReference("QueueIconSupport", new Version(0, 0, 0, 0));
						mainModule.AssemblyReferences.Add(val16);
						TypeReference t3 = new TypeReference("", "QueueIconSupport", mainModule, (IMetadataScope)(object)val16);
						instructions[num2].OpCode = OpCodes.Nop;
						instructions[num2].Operand = null;
						instructions[num2 + 1].OpCode = OpCodes.Call;
						instructions[num2 + 1].Operand = Method(t3, "SetPickupIcon", mainModule.TypeSystem.Void, ((MemberReference)val15).DeclaringType, ((MemberReference)val14).DeclaringType);
						num++;
					}
				}
			}
			Require(num == 1, rule);
			break;
		case "beam-prefab":
			foreach (MethodDefinition item4 in from m in Methods(mainModule)
				where m.HasBody
				select m)
			{
				Instruction[] array = item4.Body.Instructions.ToArray();
				foreach (Instruction val17 in array)
				{
					object operand3 = val17.Operand;
					MethodReference val18 = (MethodReference)((operand3 is MethodReference) ? operand3 : null);
					if (val18 != null && !(((MemberReference)((MemberReference)val18).DeclaringType).FullName != "R2API.PrefabAPI") && !(((MemberReference)val18).Name != "InstantiateClone") && val18.Parameters.Count == 2)
					{
						MethodReference val19 = Method(((MemberReference)val18).DeclaringType, ((MemberReference)val18).Name, val18.ReturnType, ((IEnumerable<ParameterDefinition>)val18.Parameters).Select((ParameterDefinition p) => ((ParameterReference)p).ParameterType).Concat((IEnumerable<TypeReference>)(object)new TypeReference[1] { mainModule.TypeSystem.Boolean }).ToArray());
						val17.OpCode = OpCodes.Ldc_I4_0;
						val17.Operand = null;
						item4.Body.GetILProcessor().InsertAfter(val17, Instruction.Create(OpCodes.Call, val19));
						num++;
					}
				}
			}
			Require(num == 1, rule);
			break;
		case "fast-delay-name":
			foreach (TypeDefinition item5 in from val29 in mainModule.GetTypes()
				where ((MemberReference)val29).FullName == "BalancedFasterInteractables.Plugin/PurchaseDelay"
				select val29)
			{
				MethodDefinition val20 = ((IEnumerable<MethodDefinition>)item5.Methods).Single((MethodDefinition m) => ((MemberReference)m).Name == "Update" && ((MethodReference)m).Parameters.Count == 1 && ((MemberReference)((ParameterReference)((MethodReference)m).Parameters[0]).ParameterType).FullName == "System.Single");
				foreach (MethodDefinition item6 in from m in Methods(mainModule)
					where m.HasBody
					select m)
				{
					Enumerator<Instruction> enumerator7 = item6.Body.Instructions.GetEnumerator();
					try
					{
						while (enumerator7.MoveNext())
						{
							Instruction current7 = enumerator7.Current;
							object operand4 = current7.Operand;
							MethodReference val21 = (MethodReference)((operand4 is MethodReference) ? operand4 : null);
							if (val21 != null && ((MemberReference)((MemberReference)val21).DeclaringType).FullName == ((MemberReference)item5).FullName && ((MemberReference)val21).Name == "Update" && val21.Parameters.Count == 1)
							{
								((MemberReference)val21).Name = "ApplyDelayScale";
							}
						}
					}
					finally
					{
						((IDisposable)enumerator7/*cast due to .constrained prefix*/).Dispose();
					}
				}
				((MemberReference)val20).Name = "ApplyDelayScale";
				num++;
			}
			Require(num == 1, rule);
			break;
		case "music-scene":
			foreach (MethodDefinition item7 in from m in Methods(mainModule)
				where m.HasBody
				select m)
			{
				Instruction[] array2 = item7.Body.Instructions.ToArray();
				foreach (Instruction val24 in array2)
				{
					object operand6 = val24.Operand;
					MethodReference val25 = (MethodReference)((operand6 is MethodReference) ? operand6 : null);
					if (val25 != null && !(((MemberReference)((MemberReference)val25).DeclaringType).FullName != "RoR2.SceneDef") && !(((MemberReference)val25).Name != "get_sceneDefIndex"))
					{
						ILProcessor iLProcessor2 = item7.Body.GetILProcessor();
						Instruction next = val24.Next;
						Instruction val26 = Instruction.Create(OpCodes.Callvirt, val25);
						val24.OpCode = OpCodes.Dup;
						val24.Operand = null;
						Instruction[] array3 = (Instruction[])(object)new Instruction[5]
						{
							Instruction.Create(OpCodes.Brtrue, val26),
							Instruction.Create(OpCodes.Pop),
							Instruction.Create(OpCodes.Ldc_I4_M1),
							Instruction.Create(OpCodes.Br, next),
							val26
						};
						Instruction val27 = val24;
						Instruction[] array4 = array3;
						foreach (Instruction val28 in array4)
						{
							iLProcessor2.InsertAfter(val27, val28);
							val27 = val28;
						}
						num++;
					}
				}
			}
			Require(num == 1, rule);
			break;
		case "quality-temp":
		{
			TypeDefinition type = mainModule.GetType("ItemQualities.Equipments.PassiveHealing/<>c");
			MethodDefinition val = ((IEnumerable<MethodDefinition>)type.Methods).Single((MethodDefinition x) => ((MemberReference)x).Name == "<Surprise_DropTempItemServer>b__9_3");
			Require(val.Body.Instructions.Count == 4, rule);
			AssemblyNameReference val2 = ((IEnumerable<AssemblyNameReference>)mainModule.AssemblyReferences).Single((AssemblyNameReference x) => x.Name == "Mono.Cecil");
			TypeReference t = new TypeReference("Mono.Cecil.Cil", "Instruction", mainModule, (IMetadataScope)(object)val2);
			TypeReference val3 = new TypeReference("Mono.Cecil", "MethodReference", mainModule, (IMetadataScope)(object)val2);
			TypeReference t2 = new TypeReference("Mono.Cecil", "MemberReference", mainModule, (IMetadataScope)(object)val2);
			TypeReference val4 = new TypeReference("Mono.Cecil", "TypeReference", mainModule, (IMetadataScope)(object)val2);
			MethodReference val5 = Method(t, "get_Operand", mainModule.TypeSystem.Object);
			val5.HasThis = true;
			MethodReference val6 = Method(t2, "get_Name", mainModule.TypeSystem.String);
			val6.HasThis = true;
			MethodReference val7 = Method(t2, "get_DeclaringType", val4);
			val7.HasThis = true;
			MethodReference val8 = Method(val4, "get_FullName", mainModule.TypeSystem.String);
			val8.HasThis = true;
			MethodReference val9 = Method(mainModule.TypeSystem.String, "op_Equality", mainModule.TypeSystem.Boolean, mainModule.TypeSystem.String, mainModule.TypeSystem.String);
			ILProcessor iLProcessor = val.Body.GetILProcessor();
			Instruction val10 = ((IEnumerable<Instruction>)val.Body.Instructions).Last();
			val.Body.Instructions.Remove(val10);
			Instruction val11 = Instruction.Create(OpCodes.Ldc_I4_1);
			Instruction val12 = Instruction.Create(OpCodes.Ldc_I4_0);
			VariableDefinition val13 = new VariableDefinition(val3);
			val.Body.Variables.Add(val13);
			val.Body.InitLocals = true;
			iLProcessor.Emit(OpCodes.Brtrue, val11);
			iLProcessor.Emit(OpCodes.Ldarg_1);
			iLProcessor.Emit(OpCodes.Callvirt, val5);
			iLProcessor.Emit(OpCodes.Isinst, val3);
			iLProcessor.Emit(OpCodes.Stloc, val13);
			iLProcessor.Emit(OpCodes.Ldloc, val13);
			iLProcessor.Emit(OpCodes.Brfalse, val12);
			iLProcessor.Emit(OpCodes.Ldloc, val13);
			iLProcessor.Emit(OpCodes.Callvirt, val6);
			iLProcessor.Emit(OpCodes.Ldstr, "SpawnJunkDrop");
			iLProcessor.Emit(OpCodes.Call, val9);
			iLProcessor.Emit(OpCodes.Brfalse, val12);
			iLProcessor.Emit(OpCodes.Ldloc, val13);
			iLProcessor.Emit(OpCodes.Callvirt, val7);
			iLProcessor.Emit(OpCodes.Callvirt, val8);
			iLProcessor.Emit(OpCodes.Ldstr, "JunkDroneRandomItems");
			iLProcessor.Emit(OpCodes.Call, val9);
			iLProcessor.Emit(OpCodes.Ret);
			iLProcessor.Append(val12);
			iLProcessor.Emit(OpCodes.Ret);
			iLProcessor.Append(val11);
			iLProcessor.Emit(OpCodes.Ret);
			break;
		}
		default:
			throw new InvalidDataException("Unknown compatibility rule " + rule);
		}
	}

	private static void Require(bool ok, string rule)
	{
		if (!ok)
		{
			throw new InvalidDataException("Unexpected official method layout: " + rule);
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using EntityStates.Drone.DroneJunk;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using R2API.Utils;
using RoR2;
using RoR2.Artifacts;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
[BepInPlugin("LocalMods.JunkDroneRandomItems", "Temp Item Fix (Host Only)", "1.1.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class JunkDroneRandomItems : BaseUnityPlugin
{
	public const string Guid = "LocalMods.JunkDroneRandomItems";

	[ThreadStatic]
	private static int junkDropDepth;

	private static readonly MethodInfo spawn = typeof(PickupDropletController).GetMethod("CreatePickupDroplet", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
	{
		typeof(UniquePickup),
		typeof(Vector3),
		typeof(Vector3)
	}, null);

	private static readonly MethodInfo commandEnabled = typeof(CommandArtifactManager).GetProperty("IsCommandArtifactEnabled", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(nonPublic: true);

	private static readonly MethodInfo spawnInfo = typeof(PickupDropletController).GetMethod("CreatePickupDroplet", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
	{
		typeof(CreatePickupInfo),
		typeof(Vector3),
		typeof(Vector3)
	}, null);

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Expected O, but got Unknown
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Expected O, but got Unknown
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Expected O, but got Unknown
		harmony = new Harmony("LocalMods.JunkDroneRandomItems");
		try
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(Surprise), "DropTempItemServer", new Type[1] { typeof(Vector3) }, (Type[])null);
			MethodInfo method = typeof(PickupDropletController).GetMethod("CreatePickupDroplet", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[3]
			{
				typeof(CreatePickupInfo),
				typeof(Vector3),
				typeof(Vector3)
			}, null);
			if (methodInfo == null || method == null || spawn == null || commandEnabled == null)
			{
				throw new MissingMethodException("Required native junk drone drop API not found.");
			}
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(JunkDroneRandomItems), "FilterDropletCommand", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(JunkDroneRandomItems), "ScopeJunkDrop", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Ready: host junk drone items stay random under Command. Client-only sessions use native behavior.");
			try
			{
				MethodInfo methodInfo2 = AccessTools.Method(typeof(PickupDistributorBehavior), "Drop", Type.EmptyTypes, (Type[])null);
				if (methodInfo2 == null || spawnInfo == null)
				{
					throw new MissingMethodException("Dispenser drop API not found.");
				}
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(JunkDroneRandomItems), "ScopeDispenserDrop", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Ready: host temporary item dispensers give their displayed item under Command. Permanent-item dispensers remain unchanged.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Dispenser fix unavailable; junk drone fix retained. " + ex));
			}
		}
		catch (Exception ex2)
		{
			harmony.UnpatchSelf();
			((BaseUnityPlugin)this).Logger.LogError((object)("Not enabled: incompatible drop hook. Native behavior restored. " + ex2));
		}
	}

	private void OnDestroy()
	{
		Harmony obj = harmony;
		if (obj != null)
		{
			obj.UnpatchSelf();
		}
	}

	public static bool UseCommand(bool enabled, bool isServer, int depth)
	{
		return enabled && (!isServer || depth <= 0);
	}

	public static bool CommandForThisDroplet()
	{
		return UseCommand(CommandArtifactManager.IsCommandArtifactEnabled, NetworkServer.active, junkDropDepth);
	}

	public static void SpawnJunkDrop(UniquePickup pickup, Vector3 position, Vector3 velocity)
	{
		//IL_001c: 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_001e: Unknown result type (might be due to invalid IL or missing references)
		if (!NetworkServer.active)
		{
			return;
		}
		junkDropDepth++;
		try
		{
			PickupDropletController.CreatePickupDroplet(pickup, position, velocity);
		}
		finally
		{
			junkDropDepth--;
		}
	}

	public static IEnumerable<CodeInstruction> ScopeJunkDrop(IEnumerable<CodeInstruction> input)
	{
		return ReplaceOne(input, spawn, typeof(JunkDroneRandomItems).GetMethod("SpawnJunkDrop"));
	}

	public static bool IsTemporaryDispenserDrop(bool isServer, float decayValue)
	{
		return isServer && decayValue > 0f;
	}

	public static void SpawnDispenserDrop(CreatePickupInfo info, Vector3 position, Vector3 velocity)
	{
		//IL_0012: 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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		if (!NetworkServer.active)
		{
			return;
		}
		bool flag = IsTemporaryDispenserDrop(isServer: true, ((CreatePickupInfo)(ref info)).pickup.decayValue);
		if (flag)
		{
			junkDropDepth++;
		}
		try
		{
			PickupDropletController.CreatePickupDroplet(info, position, velocity);
		}
		finally
		{
			if (flag)
			{
				junkDropDepth--;
			}
		}
	}

	public static IEnumerable<CodeInstruction> ScopeDispenserDrop(IEnumerable<CodeInstruction> input)
	{
		return ReplaceOne(input, spawnInfo, typeof(JunkDroneRandomItems).GetMethod("SpawnDispenserDrop"));
	}

	public static IEnumerable<CodeInstruction> FilterDropletCommand(IEnumerable<CodeInstruction> input)
	{
		return ReplaceOne(input, commandEnabled, typeof(JunkDroneRandomItems).GetMethod("CommandForThisDroplet"));
	}

	private static IEnumerable<CodeInstruction> ReplaceOne(IEnumerable<CodeInstruction> input, MethodInfo original, MethodInfo replacement)
	{
		List<CodeInstruction> list = input.Select((Func<CodeInstruction, CodeInstruction>)((CodeInstruction i) => new CodeInstruction(i))).ToList();
		List<CodeInstruction> list2 = list.Where((CodeInstruction i) => i.opcode == OpCodes.Call && object.Equals(i.operand, original)).ToList();
		if (original == null || replacement == null || list2.Count != 1)
		{
			throw new InvalidOperationException("Expected exactly one native call; refusing an unrecognized game/mod layout.");
		}
		list2[0].operand = replacement;
		return list;
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using Microsoft.CodeAnalysis;
using RoR2;
using RoR2.ContentManagement;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
[BepInPlugin("ClientSideRepairs.CommandQueueIcons", "Command Queue Icon Compatibility", "1.0.0")]
public class QueueIconSupport : BaseUnityPlugin
{
	public static void SetPickupIcon(Image image, PickupDef pickup)
	{
		if (Object.op_Implicit((Object)(object)image) && pickup != null)
		{
			QueueIconLoader queueIconLoader = ((Component)image).gameObject.GetComponent<QueueIconLoader>();
			if (!Object.op_Implicit((Object)(object)queueIconLoader))
			{
				queueIconLoader = ((Component)image).gameObject.AddComponent<QueueIconLoader>();
			}
			queueIconLoader.Set(image, pickup);
		}
	}
}
public class QueueIconLoader : MonoBehaviour
{
	private AssetOrDirectReference<Sprite> reference;

	private int generation;

	public void Set(Image image, PickupDef pickup)
	{
		int current = ++generation;
		((Behaviour)image).enabled = false;
		reference = pickup.GetIconAODR(true, (Action<Sprite>)delegate(Sprite sprite)
		{
			if (Object.op_Implicit((Object)(object)image) && current == generation)
			{
				image.sprite = sprite;
				((Behaviour)image).enabled = Object.op_Implicit((Object)(object)sprite);
			}
		}, (Action<Sprite>)delegate
		{
			if (Object.op_Implicit((Object)(object)image) && current == generation)
			{
				((Behaviour)image).enabled = false;
			}
		});
		reference.SetUnloadType((AsyncReferenceHandleUnloadType)3);
	}

	private void OnDestroy()
	{
		generation++;
		reference = null;
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RoR2;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
public static class ExactQueueChoice
{
	public static int Resolve(int wanted, int[] ids, bool[] available)
	{
		if (wanted < 0 || ids == null || available == null || ids.Length != available.Length)
		{
			return -1;
		}
		int num = -1;
		for (int i = 0; i < ids.Length; i++)
		{
			if (ids[i] == wanted)
			{
				if (num >= 0)
				{
					return -1;
				}
				num = i;
			}
		}
		return (num >= 0 && available[num]) ? num : (-1);
	}
}
[BepInPlugin("ClientSideRepairs.CommandQueueSelectionGuard", "Command Queue Exact Item Guard", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class CommandQueueSelectionGuard : BaseUnityPlugin
{
	private sealed class Request
	{
		public PickupPickerController picker;

		public PickupIndex wanted;

		public bool reached;
	}

	private static CommandQueueSelectionGuard instance;

	private static Func<IEnumerable<(ItemTier, PickupIndex)>> heads;

	private static Func<ItemTier, PickupIndex> peek;

	private static Func<ItemTier, PickupIndex> pop;

	private static FieldInfo prefab;

	private static bool audited;

	private static bool validCatalog;

	[ThreadStatic]
	private static Request active;

	private readonly HashSet<PickupPickerController> pending = new HashSet<PickupPickerController>();

	private void Awake()
	{
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Expected O, but got Unknown
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Expected O, but got Unknown
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Expected O, but got Unknown
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Expected O, but got Unknown
		instance = this;
		Type type = AccessTools.TypeByName("CommandQueue.QueueManager");
		heads = (Func<IEnumerable<(ItemTier, PickupIndex)>>)Delegate.CreateDelegate(typeof(Func<IEnumerable<(ItemTier, PickupIndex)>>), AccessTools.Method(type, "PeekAll", (Type[])null, (Type[])null));
		peek = (Func<ItemTier, PickupIndex>)Delegate.CreateDelegate(typeof(Func<ItemTier, PickupIndex>), AccessTools.Method(type, "Peek", (Type[])null, (Type[])null));
		pop = (Func<ItemTier, PickupIndex>)Delegate.CreateDelegate(typeof(Func<ItemTier, PickupIndex>), AccessTools.Method(type, "Pop", (Type[])null, (Type[])null));
		prefab = AccessTools.Field(AccessTools.TypeByName("CommandQueue.CommandQueue"), "commandUIPrefab");
		Harmony val = new Harmony("ClientSideRepairs.CommandQueueSelectionGuard");
		val.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("CommandQueue.CommandQueue"), "HandleCommandDisplayBegin", (Type[])null, (Type[])null), new HarmonyMethod(typeof(CommandQueueSelectionGuard), "BeforeQueue", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LookingGlass.CommandItemCount.CommandItemCountClass"), "SubmitChoice", (Type[])null, (Type[])null), new HarmonyMethod(typeof(CommandQueueSelectionGuard), "BeforeRemap", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(PickupPickerController), "SubmitChoice", new Type[1] { typeof(int) }, (Type[])null), new HarmonyMethod(typeof(CommandQueueSelectionGuard), "BeforeNativeSubmit", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Exact-item queue guard installed. Queued choices bypass display-only sorting; every submission is revalidated. Catalog audit waits for catalogs.");
	}

	private unsafe void Update()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: 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_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		if (audited || !((ResourceAvailability)(ref PickupCatalog.availability)).available || !((ResourceAvailability)(ref ItemCatalog.availability)).available)
		{
			return;
		}
		audited = true;
		validCatalog = true;
		int num = 0;
		int num2 = 0;
		GenericStaticEnumerable<ItemIndex, AllItemsEnumerator> allItems = ItemCatalog.allItems;
		AllItemsEnumerator enumerator = allItems.GetEnumerator();
		try
		{
			while (((AllItemsEnumerator)(ref enumerator)).MoveNext())
			{
				ItemIndex current = ((AllItemsEnumerator)(ref enumerator)).Current;
				ItemDef itemDef = ItemCatalog.GetItemDef(current);
				if (!Object.op_Implicit((Object)(object)itemDef))
				{
					continue;
				}
				PickupIndex val = PickupCatalog.FindPickupIndex(current);
				if (!(val == PickupIndex.none))
				{
					PickupDef pickupDef = PickupCatalog.GetPickupDef(val);
					if (pickupDef == null || pickupDef.itemIndex != current)
					{
						validCatalog = false;
					}
					num++;
				}
			}
		}
		finally
		{
			((IDisposable)(*(AllItemsEnumerator*)(&enumerator))/*cast due to .constrained prefix*/).Dispose();
		}
		GenericStaticEnumerable<EquipmentIndex, AllEquipmentEnumerator> allEquipment = EquipmentCatalog.allEquipment;
		AllEquipmentEnumerator enumerator2 = allEquipment.GetEnumerator();
		try
		{
			while (((AllEquipmentEnumerator)(ref enumerator2)).MoveNext())
			{
				EquipmentIndex current2 = ((AllEquipmentEnumerator)(ref enumerator2)).Current;
				EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(current2);
				if (!Object.op_Implicit((Object)(object)equipmentDef))
				{
					continue;
				}
				PickupIndex val2 = PickupCatalog.FindPickupIndex(current2);
				if (!(val2 == PickupIndex.none))
				{
					PickupDef pickupDef2 = PickupCatalog.GetPickupDef(val2);
					if (pickupDef2 == null || pickupDef2.equipmentIndex != current2)
					{
						validCatalog = false;
					}
					num2++;
				}
			}
		}
		finally
		{
			((IDisposable)(*(AllEquipmentEnumerator*)(&enumerator2))/*cast due to .constrained prefix*/).Dispose();
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)("Full pickup catalog identity audit: " + num + " items, " + num2 + " equipment; valid=" + validCatalog + ". No hard-coded item IDs."));
		if (!validCatalog)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Catalog identities disagree; queued auto-picks disabled. Use manual menus.");
		}
	}

	private static int Resolve(PickupPickerController picker, PickupIndex wanted)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		if (!Object.op_Implicit((Object)(object)picker) || picker.options == null || PickupCatalog.GetPickupDef(wanted) == null)
		{
			return -1;
		}
		return ExactQueueChoice.Resolve(wanted.value, picker.options.Select((Option o) => o.pickup.pickupIndex.value).ToArray(), picker.options.Select((Option o) => o.available).ToArray());
	}

	private static void Manual(object[] args)
	{
		((Delegate)args[0]).DynamicInvoke(args.Skip(1).ToArray());
	}

	private static bool BeforeQueue(object[] __args)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected O, but got Unknown
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Expected O, but got Unknown
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		PickupPickerController val = (PickupPickerController)__args[1];
		if (!Object.op_Implicit((Object)(object)val) || (Object)(object)val.panelPrefab != (Object)(GameObject)prefab.GetValue(null))
		{
			return true;
		}
		if (!audited || !validCatalog)
		{
			Manual(__args);
			return false;
		}
		foreach (var item in heads())
		{
			if (Resolve(val, item.Item2) >= 0)
			{
				if (instance.pending.Add(val))
				{
					((MonoBehaviour)instance).StartCoroutine(instance.PickLater((object[])__args.Clone(), item.Item1, item.Item2));
				}
				return false;
			}
		}
		Manual(__args);
		return false;
	}

	private IEnumerator PickLater(object[] args, ItemTier tier, PickupIndex wanted)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: 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)
		PickupPickerController picker = (PickupPickerController)args[1];
		yield return null;
		pending.Remove(picker);
		if (!Object.op_Implicit((Object)(object)picker))
		{
			yield break;
		}
		int choice = Resolve(picker, wanted);
		if (choice < 0 || peek(tier) != wanted)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Queued item unavailable or queue changed; opening manual menu without consuming the queue.");
			Manual(args);
			yield break;
		}
		Request request = (active = new Request
		{
			picker = picker,
			wanted = wanted
		});
		try
		{
			picker.SubmitChoice(choice);
		}
		finally
		{
			active = null;
		}
		if (request.reached)
		{
			if (peek(tier) == wanted)
			{
				pop(tier);
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Verified queued choice: " + PickupCatalog.GetPickupDef(wanted).internalName + "; native option " + choice + "."));
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"Auto-pick blocked before native submission; queue retained.");
			if (Object.op_Implicit((Object)(object)picker))
			{
				Manual(args);
			}
		}
	}

	private static bool BeforeRemap(object[] __args)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		if (active == null || (Object)(PickupPickerController)__args[1] != (Object)(object)active.picker)
		{
			return true;
		}
		int num = (int)__args[2];
		if (Resolve(active.picker, active.wanted) != num)
		{
			return false;
		}
		((Action<PickupPickerController, int>)__args[0])(active.picker, num);
		return false;
	}

	private static bool BeforeNativeSubmit(PickupPickerController __instance, int __0)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		if (active == null || (Object)(object)__instance != (Object)(object)active.picker)
		{
			return true;
		}
		if (Resolve(__instance, active.wanted) != __0)
		{
			((BaseUnityPlugin)instance).Logger.LogError((object)"Refused wrong queued choice. Queue retained; no selection submitted.");
			return false;
		}
		active.reached = true;
		return true;
	}
}