using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using CartelEnforcer;
using HarmonyLib;
using Il2CppFishNet;
using Il2CppFishNet.Connection;
using Il2CppFishNet.Managing;
using Il2CppFishNet.Managing.Object;
using Il2CppFishNet.Object;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne;
using Il2CppScheduleOne.AvatarFramework;
using Il2CppScheduleOne.AvatarFramework.Equipping;
using Il2CppScheduleOne.Cartel;
using Il2CppScheduleOne.Combat;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Dialogue;
using Il2CppScheduleOne.Doors;
using Il2CppScheduleOne.Economy;
using Il2CppScheduleOne.GameTime;
using Il2CppScheduleOne.Graffiti;
using Il2CppScheduleOne.Interaction;
using Il2CppScheduleOne.ItemFramework;
using Il2CppScheduleOne.Law;
using Il2CppScheduleOne.Levelling;
using Il2CppScheduleOne.Lighting;
using Il2CppScheduleOne.Map;
using Il2CppScheduleOne.Messaging;
using Il2CppScheduleOne.Misc;
using Il2CppScheduleOne.Money;
using Il2CppScheduleOne.NPCs;
using Il2CppScheduleOne.NPCs.Behaviour;
using Il2CppScheduleOne.NPCs.CharacterClasses;
using Il2CppScheduleOne.NPCs.Other;
using Il2CppScheduleOne.NPCs.Relation;
using Il2CppScheduleOne.NPCs.Schedules;
using Il2CppScheduleOne.ObjectScripts;
using Il2CppScheduleOne.Packaging;
using Il2CppScheduleOne.Persistence;
using Il2CppScheduleOne.PlayerScripts;
using Il2CppScheduleOne.Police;
using Il2CppScheduleOne.Product;
using Il2CppScheduleOne.Product.Packaging;
using Il2CppScheduleOne.Property;
using Il2CppScheduleOne.Quests;
using Il2CppScheduleOne.Storage;
using Il2CppScheduleOne.UI;
using Il2CppScheduleOne.UI.Handover;
using Il2CppScheduleOne.UI.MainMenu;
using Il2CppScheduleOne.UI.Phone.Messages;
using Il2CppScheduleOne.Vehicles;
using Il2CppScheduleOne.Vehicles.AI;
using Il2CppScheduleOne.VoiceOver;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(global::CartelEnforcer.CartelEnforcer), "Cartel Enforcer", "1.7.2", "XOWithSauce", null)]
[assembly: MelonColor]
[assembly: MelonOptionalDependencies(new string[] { "FishNet.Runtime" })]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: MelonPlatformDomain(/*Could not decode attribute arguments.*/)]
[assembly: VerifyLoaderVersion("0.7.0", true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("XOWithSauce")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright XOWithSauce 2025 Source MIT")]
[assembly: AssemblyDescription("Schedule I Cartel Enforcer Mod")]
[assembly: AssemblyFileVersion("1.7.2.0")]
[assembly: AssemblyInformationalVersion("1.7.2")]
[assembly: AssemblyProduct("Cartel Enforcer")]
[assembly: AssemblyTitle("CartelEnforcer-IL2Cpp")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/XOWithSauce/schedule-cartelenforcer")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("1.0.0.0")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CartelEnforcer
{
	public static class DealerActivity
	{
		[HarmonyPatch(typeof(Dealer), "DealerUnconscious")]
		public static class Dealer_DealerUnconscious_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(Dealer __instance)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				if ((int)__instance.DealerType == 1)
				{
					Enumerator<Contract> enumerator = __instance.ActiveContracts.GetEnumerator();
					while (enumerator.MoveNext())
					{
						Contract current = enumerator.Current;
						Dictionary<string, Tuple<Dealer, int>> playerDealerStolen = DealerActivity.playerDealerStolen;
						Guid gUID = ((Quest)current).GUID;
						if (!playerDealerStolen.ContainsKey(((object)(Guid)(ref gUID)).ToString()))
						{
							((Quest)current).Fail(true);
						}
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Customer), "ProcessHandover")]
		public static class Customer_ProcessHandover_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(Customer __instance, EHandoverOutcome outcome, Contract contract, List<ItemInstance> items, bool handoverByPlayer, bool giveBonuses = true)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: 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_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				if (handoverByPlayer)
				{
					return true;
				}
				if ((Object)(object)contract.Dealer == (Object)null)
				{
					return true;
				}
				Dictionary<string, Tuple<Dealer, int>> playerDealerStolen = DealerActivity.playerDealerStolen;
				Guid gUID = ((Quest)contract).GUID;
				if (!playerDealerStolen.ContainsKey(((object)(Guid)(ref gUID)).ToString()))
				{
					return true;
				}
				Dictionary<string, Tuple<Dealer, int>> playerDealerStolen2 = DealerActivity.playerDealerStolen;
				gUID = ((Quest)contract).GUID;
				playerDealerStolen2.TryGetValue(((object)(Guid)(ref gUID)).ToString(), out var value);
				if (value == null)
				{
					return true;
				}
				Dealer item = value.Item1;
				int item2 = value.Item2;
				float num = Vector3.Distance(__instance.NPC.CenterPoint, ((NPC)contract.Dealer).CenterPoint);
				float num2 = Vector3.Distance(__instance.NPC.CenterPoint, ((NPC)item).CenterPoint);
				if (num2 < num && num2 < 2f)
				{
					if (contract.Dealer.ActiveContracts.Count != 0 && (Object)(object)contract.Dealer.ActiveContracts[0] == (Object)(object)contract)
					{
						((Quest)contract.Dealer.ActiveContracts[0]).Fail(true);
					}
					contract.Dealer = item;
					((Quest)contract).CompletionXP = item2;
					contract.completedContractsIncremented = true;
				}
				else if (num < num2 && num2 < 2f && item.ActiveContracts.Count != 0 && (Object)(object)item.ActiveContracts[0] == (Object)(object)contract)
				{
					((Quest)item.ActiveContracts[0]).Fail(true);
				}
				Dictionary<string, Tuple<Dealer, int>> playerDealerStolen3 = DealerActivity.playerDealerStolen;
				gUID = ((Quest)contract).GUID;
				playerDealerStolen3.Remove(((object)(Guid)(ref gUID)).ToString());
				List<string> consumedGUIDs = DealerActivity.consumedGUIDs;
				gUID = ((Quest)contract).GUID;
				consumedGUIDs.Add(((object)(Guid)(ref gUID)).ToString());
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <DespawnDefenderGoonsSoon>d__20 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<CartelGoon> goons;

			private int <maxHoursWaited>5__2;

			private int <goonsDead>5__3;

			private int <i>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DespawnDefenderGoonsSoon>d__20(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				Enumerator<CartelGoon> enumerator;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<maxHoursWaited>5__2 = 2;
					<goonsDead>5__3 = 0;
					<i>5__4 = 0;
					goto IL_00eb;
				case 1:
					<>1__state = -1;
					enumerator = goons.GetEnumerator();
					while (enumerator.MoveNext())
					{
						CartelGoon current = enumerator.Current;
						if ((((NPC)current).Health.IsDead || ((NPC)current).Health.IsKnockedOut) && current.IsGoonSpawned)
						{
							<goonsDead>5__3++;
							((NPC)current).Health.Revive();
							current.Despawn();
							((Behaviour)((NPC)current).Behaviour.CombatBehaviour).Disable_Networked((NetworkConnection)null);
						}
					}
					if (<goonsDead>5__3 != goons.Count)
					{
						<i>5__4++;
						goto IL_00eb;
					}
					goto IL_00fc;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_00eb:
					if (<i>5__4 < <maxHoursWaited>5__2)
					{
						<>2__current = CartelEnforcer.Wait60;
						<>1__state = 1;
						return true;
					}
					goto IL_00fc;
					IL_00fc:
					enumerator = goons.GetEnumerator();
					while (enumerator.MoveNext())
					{
						CartelGoon current2 = enumerator.Current;
						if (current2.IsGoonSpawned)
						{
							current2.Despawn();
							((Behaviour)((NPC)current2).Behaviour.CombatBehaviour).Disable_Networked((NetworkConnection)null);
						}
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EvaluateDealerState>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private bool <isHostile>5__2;

			private bool <safetyThresholdMet>5__3;

			private CartelDealer[] <>7__wrap3;

			private int <>7__wrap4;

			private CartelDealer <d>5__6;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EvaluateDealerState>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap3 = null;
				<d>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CartelEnforcer.Wait5;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					allCartelDealers = Il2CppArrayBase<CartelDealer>.op_Implicit(Object.FindObjectsOfType<CartelDealer>(true));
					Dealer[] array = Il2CppArrayBase<Dealer>.op_Implicit(Object.FindObjectsOfType<Dealer>(true));
					foreach (Dealer val in array)
					{
						if ((int)val.DealerType == 0)
						{
							allDealers.Add(val);
						}
					}
					currentStayInsideStart = defaultStayInsideStart;
					currentStayInsideEnd = defaultStayInsideEnd;
					currentStayInsideDur = defaultStayInsideDur;
					SetupDealers();
					TimeManager instance = NetworkSingleton<TimeManager>.Instance;
					instance.onDayPass += Action.op_Implicit((Action)OnDayPassChange);
					goto IL_053d;
				}
				case 2:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= 1620 || NetworkSingleton<TimeManager>.Instance.CurrentTime <= 359)
					{
						<isHostile>5__2 = true;
						if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
						{
							<isHostile>5__2 = false;
						}
						if (currentDealerActivity != previousDealerActivity)
						{
							int num = 0;
							int num2 = 0;
							int num3 = 0;
							if (currentDealerActivity > 0f)
							{
								int minSumFrom24HourTime = TimeManager.GetMinSumFrom24HourTime(currentStayInsideStart);
								int minSumFrom24HourTime2 = TimeManager.GetMinSumFrom24HourTime(359);
								int num4 = Mathf.RoundToInt(Mathf.Lerp((float)minSumFrom24HourTime, (float)minSumFrom24HourTime2, currentDealerActivity));
								num = TimeManager.Get24HourTimeFromMinSum(num4);
								if (num == 400)
								{
									num = 359;
								}
								int minSumFrom24HourTime3 = TimeManager.GetMinSumFrom24HourTime(currentStayInsideEnd);
								int minSumFrom24HourTime4 = TimeManager.GetMinSumFrom24HourTime(1620);
								int num5 = Mathf.RoundToInt(Mathf.Lerp((float)minSumFrom24HourTime3, (float)minSumFrom24HourTime4, currentDealerActivity));
								num2 = TimeManager.Get24HourTimeFromMinSum(num5);
								num3 = num5 - num4;
							}
							else if (currentDealerActivity < 0f)
							{
								float num6 = 0f - currentDealerActivity;
								int minSumFrom24HourTime5 = TimeManager.GetMinSumFrom24HourTime(currentStayInsideStart);
								int minSumFrom24HourTime6 = TimeManager.GetMinSumFrom24HourTime(2);
								int num7 = Mathf.RoundToInt(Mathf.Lerp((float)minSumFrom24HourTime5, (float)minSumFrom24HourTime6, num6));
								num = TimeManager.Get24HourTimeFromMinSum(num7);
								int minSumFrom24HourTime7 = TimeManager.GetMinSumFrom24HourTime(currentStayInsideEnd);
								int minSumFrom24HourTime8 = TimeManager.GetMinSumFrom24HourTime(2359);
								int num8 = Mathf.RoundToInt(Mathf.Lerp((float)minSumFrom24HourTime7, (float)minSumFrom24HourTime8, num6));
								num2 = TimeManager.Get24HourTimeFromMinSum(num8);
								num3 = num8 - num7;
							}
							else
							{
								num = defaultStayInsideStart;
								num2 = defaultStayInsideEnd;
								num3 = defaultStayInsideDur;
							}
							currentStayInsideStart = num;
							currentStayInsideEnd = num2;
							currentStayInsideDur = num3;
							<>7__wrap3 = allCartelDealers;
							<>7__wrap4 = 0;
							goto IL_0310;
						}
						goto IL_0327;
					}
					goto IL_053d;
				case 3:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					ApplyNewEventState(<d>5__6, currentStayInsideStart, currentStayInsideEnd, currentStayInsideDur);
					<d>5__6 = null;
					<>7__wrap4++;
					goto IL_0310;
				case 4:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					ApplyNewEventState(<d>5__6, 600, 559, 1439);
					<d>5__6.SetIsAcceptingDeals(false);
					<d>5__6 = null;
					<>7__wrap4++;
					goto IL_03e8;
				case 5:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					if (!((NPC)<d>5__6).isInBuilding && !((NPC)<d>5__6).Movement.HasDestination && !((NPC)<d>5__6).Health.IsDead && !((NPC)<d>5__6).Health.IsKnockedOut)
					{
						WalkToInterestPoint(<d>5__6);
					}
					<d>5__6 = null;
					<>7__wrap4++;
					goto IL_04c9;
				case 6:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					goto IL_053d;
				case 7:
					{
						<>1__state = -1;
						return false;
					}
					IL_0327:
					previousDealerActivity = currentDealerActivity;
					<safetyThresholdMet>5__3 = false;
					if (dealerConfig.SafetyEnabled && currentDealerActivity <= dealerConfig.SafetyThreshold)
					{
						<safetyThresholdMet>5__3 = true;
						<>7__wrap3 = allCartelDealers;
						<>7__wrap4 = 0;
						goto IL_03e8;
					}
					goto IL_0402;
					IL_03e8:
					if (<>7__wrap4 < <>7__wrap3.Length)
					{
						<d>5__6 = <>7__wrap3[<>7__wrap4];
						<>2__current = CartelEnforcer.Wait05;
						<>1__state = 4;
						return true;
					}
					<>7__wrap3 = null;
					goto IL_0402;
					IL_053d:
					if (CartelEnforcer.registered)
					{
						<>2__current = CartelEnforcer.Wait60;
						<>1__state = 2;
						return true;
					}
					<>2__current = null;
					<>1__state = 7;
					return true;
					IL_0310:
					if (<>7__wrap4 < <>7__wrap3.Length)
					{
						<d>5__6 = <>7__wrap3[<>7__wrap4];
						<>2__current = CartelEnforcer.Wait05;
						<>1__state = 3;
						return true;
					}
					<>7__wrap3 = null;
					goto IL_0327;
					IL_04c9:
					if (<>7__wrap4 < <>7__wrap3.Length)
					{
						<d>5__6 = <>7__wrap3[<>7__wrap4];
						<>2__current = CartelEnforcer.Wait2;
						<>1__state = 5;
						return true;
					}
					<>7__wrap3 = null;
					<>2__current = CartelEnforcer.Wait60;
					<>1__state = 6;
					return true;
					IL_0402:
					if (!<safetyThresholdMet>5__3)
					{
						if (!<isHostile>5__2)
						{
							<>7__wrap3 = allCartelDealers;
							<>7__wrap4 = 0;
							goto IL_04c9;
						}
						if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= currentStayInsideEnd || NetworkSingleton<TimeManager>.Instance.CurrentTime <= currentStayInsideStart)
						{
							CartelEnforcer.coros.Add(MelonCoroutines.Start(StartActiveSignal()));
						}
					}
					goto IL_053d;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnCartelCustomerDeal>d__27 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool started;

			public CartelCustomerDeal dealEvent;

			private List<Customer> <regionLockedCustomers>5__2;

			private int <i>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnCartelCustomerDeal>d__27(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<regionLockedCustomers>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_020d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_026b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0329: Unknown result type (might be due to invalid IL or missing references)
				//IL_0345: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_034d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CartelEnforcer.Wait2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (started)
					{
						<regionLockedCustomers>5__2 = new List<Customer>();
						<i>5__3 = 0;
						goto IL_005e;
					}
					goto IL_0398;
				case 2:
				{
					<>1__state = -1;
					if (<i>5__3 < Customer.LockedCustomers.Count)
					{
						if (Customer.LockedCustomers[<i>5__3].NPC.Region == ((CartelActivity)dealEvent).Region && !<regionLockedCustomers>5__2.Contains(Customer.LockedCustomers[<i>5__3]))
						{
							<regionLockedCustomers>5__2.Add(Customer.LockedCustomers[<i>5__3]);
						}
						<i>5__3++;
						if (<i>5__3 < Customer.LockedCustomers.Count && CartelEnforcer.registered)
						{
							goto IL_005e;
						}
					}
					if (<regionLockedCustomers>5__2.Count == 0)
					{
						((CartelActivity)dealEvent).Deactivate();
						return false;
					}
					int num = Random.Range(0, <regionLockedCustomers>5__2.Count);
					Customer val = null;
					for (int i = 0; i < <regionLockedCustomers>5__2.Count; i++)
					{
						val = <regionLockedCustomers>5__2[num];
						bool flag = true;
						if ((Object)(object)val.CurrentContract != (Object)null)
						{
							flag = false;
						}
						if (!val.NPC.IsConscious)
						{
							flag = false;
						}
						int orderTime = val.customerData.OrderTime;
						int num2 = TimeManager.AddMinutesTo24HourTime(orderTime, 240);
						if (!NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(orderTime, num2))
						{
							flag = false;
						}
						if (!flag)
						{
							if (i == <regionLockedCustomers>5__2.Count - 1)
							{
								((CartelActivity)dealEvent).Deactivate();
								val = null;
								return false;
							}
							num = (num + 1) % <regionLockedCustomers>5__2.Count;
						}
					}
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					EQuality correspondingQuality = StandardsMethod.GetCorrespondingQuality(val.customerData.Standards);
					new List<ProductDefinition>();
					bool flag2 = false;
					ProductItemInstance val2 = null;
					QualityItemInstance val3 = null;
					Enumerator<ItemSlot> enumerator = ((Dealer)dealEvent.dealer).GetAllSlots().GetEnumerator();
					while (enumerator.MoveNext())
					{
						ItemSlot current = enumerator.Current;
						if (current.ItemInstance == null)
						{
							continue;
						}
						val2 = ((Il2CppObjectBase)current.ItemInstance).TryCast<ProductItemInstance>();
						if (val2 != null)
						{
							if (((QualityItemInstance)val2).Quality < correspondingQuality)
							{
								flag2 = true;
								((QualityItemInstance)val2).Quality = correspondingQuality;
							}
							else
							{
								flag2 = true;
							}
							break;
						}
						val2 = null;
					}
					if (!flag2)
					{
						ItemInstance defaultInstance = Registry.GetItem("cocaine").GetDefaultInstance(4);
						val3 = ((Il2CppObjectBase)defaultInstance).TryCast<QualityItemInstance>();
						if (val3 != null)
						{
							val3.Quality = correspondingQuality;
						}
						if (((NPC)dealEvent.dealer).Inventory.CanItemFit(defaultInstance))
						{
							((NPC)dealEvent.dealer).Inventory.InsertItem(defaultInstance, true);
						}
					}
					ContractInfo val4 = val.TryGenerateContract((Dealer)(object)dealEvent.dealer);
					if (val4 != null)
					{
						int offeredDeals = val.OfferedDeals;
						val.OfferedDeals = offeredDeals + 1;
						val.TimeSinceLastDealOffered = 0;
						val.OfferedContractInfo = val4;
						val.OfferedContractTime = NetworkSingleton<TimeManager>.Instance.GetDateTime();
						val.HasChanged = true;
						EDealWindow dealWindow = ((Dealer)dealEvent.dealer).GetDealWindow();
						Contract val5 = val.ContractAccepted(dealWindow, false, (Dealer)(object)dealEvent.dealer);
						((Quest)val5).CompletionXP = 0;
						val5.completedContractsIncremented = false;
						((Dealer)dealEvent.dealer).AddContract(val5);
					}
					else
					{
						((CartelActivity)dealEvent).Deactivate();
					}
					<regionLockedCustomers>5__2 = null;
					goto IL_0398;
				}
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_005e:
					<>2__current = CartelEnforcer.Wait025;
					<>1__state = 2;
					return true;
					IL_0398:
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <StartActiveSignal>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private Dictionary<EMapRegion, Contract> <validContracts>5__2;

			private Contract <contract>5__3;

			private List<Customer> <cList>5__4;

			private List<Customer> <validCustomers>5__5;

			private List<Dealer>.Enumerator <>7__wrap5;

			private Dealer <playerDealer>5__7;

			private int <i>5__8;

			private CartelDealer[] <>7__wrap8;

			private CartelDealer <d>5__10;

			private bool <actionTaken>5__11;

			private Customer <c>5__12;

			private ContractInfo <contractInfo>5__13;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <StartActiveSignal>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<validContracts>5__2 = null;
				<contract>5__3 = null;
				<cList>5__4 = null;
				<validCustomers>5__5 = null;
				<>7__wrap5 = default(List<Dealer>.Enumerator);
				<playerDealer>5__7 = null;
				<>7__wrap8 = null;
				<d>5__10 = null;
				<c>5__12 = null;
				<contractInfo>5__13 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0764: Unknown result type (might be due to invalid IL or missing references)
				//IL_0769: Unknown result type (might be due to invalid IL or missing references)
				//IL_0772: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: 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_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_045b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0474: Unknown result type (might be due to invalid IL or missing references)
				//IL_049f: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0617: Unknown result type (might be due to invalid IL or missing references)
				//IL_0621: Expected O, but got Unknown
				//IL_0528: Unknown result type (might be due to invalid IL or missing references)
				//IL_052d: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					Guid gUID;
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<validContracts>5__2 = new Dictionary<EMapRegion, Contract>();
						<contract>5__3 = null;
						<>7__wrap5 = allDealers.GetEnumerator();
						<>1__state = -3;
						goto IL_01b6;
					case 1:
						<>1__state = -3;
						if (!CartelEnforcer.registered)
						{
							result = false;
							<>m__Finally1();
							break;
						}
						if (<playerDealer>5__7.ActiveContracts.Count != 0)
						{
							<contract>5__3 = <playerDealer>5__7.ActiveContracts[Random.Range(0, <playerDealer>5__7.ActiveContracts.Count)];
							List<string> contractGuids = InterceptEvent.contractGuids;
							gUID = ((Quest)<contract>5__3).GUID;
							if (!contractGuids.Contains(((object)(Guid)(ref gUID)).ToString()) && !<validContracts>5__2.ContainsValue(<contract>5__3))
							{
								List<string> consumedGUIDs2 = DealerActivity.consumedGUIDs;
								gUID = ((Quest)<contract>5__3).GUID;
								if (!consumedGUIDs2.Contains(((object)(Guid)(ref gUID)).ToString()))
								{
									Dictionary<string, Tuple<Dealer, int>> playerDealerStolen3 = DealerActivity.playerDealerStolen;
									gUID = ((Quest)<contract>5__3).GUID;
									if (!playerDealerStolen3.ContainsKey(((object)(Guid)(ref gUID)).ToString()))
									{
										EMapRegion regionFromPosition = Singleton<Map>.Instance.GetRegionFromPosition(<contract>5__3.DeliveryLocation.CustomerStandPoint.position);
										if (!<validContracts>5__2.ContainsKey(regionFromPosition))
										{
											<validContracts>5__2.Add(regionFromPosition, <contract>5__3);
										}
									}
								}
							}
							<playerDealer>5__7 = null;
						}
						goto IL_01b6;
					case 2:
						<>1__state = -1;
						if (!CartelEnforcer.registered)
						{
							result = false;
							break;
						}
						<cList>5__4.Add(Customer.UnlockedCustomers[<i>5__8]);
						<i>5__8++;
						goto IL_0254;
					case 3:
					{
						<>1__state = -1;
						if (!CartelEnforcer.registered)
						{
							result = false;
							break;
						}
						Customer val = <cList>5__4[Random.Range(0, <cList>5__4.Count)];
						if ((Object)(object)val.CurrentContract == (Object)null && (Object)(object)val.AssignedDealer == (Object)null && val.offeredContractInfo != null)
						{
							<validCustomers>5__5.Add(val);
						}
						<cList>5__4.Remove(val);
						if (<cList>5__4.Count > 0)
						{
							goto IL_0271;
						}
						<>7__wrap8 = allCartelDealers;
						<i>5__8 = 0;
						goto IL_0891;
					}
					case 4:
						<>1__state = -1;
						if (!CartelEnforcer.registered)
						{
							result = false;
							break;
						}
						if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= currentStayInsideEnd || NetworkSingleton<TimeManager>.Instance.CurrentTime <= currentStayInsideStart)
						{
							if ((!((Object)(object)InterceptEvent.interceptor != (Object)null) || !((Object)(object)InterceptEvent.interceptor == (Object)(object)<d>5__10)) && !((NPC)<d>5__10).Health.IsDead && !((NPC)<d>5__10).Health.IsKnockedOut && ((Dealer)<d>5__10).ActiveContracts != null)
							{
								if (((Dealer)<d>5__10).ActiveContracts.Count == 0)
								{
									<actionTaken>5__11 = false;
									if (<validContracts>5__2.Count > 0 && Random.Range(0.01f, 1f) < dealerConfig.StealDealerContractChance && dealerConfig.StealDealerContractChance != 0f)
									{
										if (<validContracts>5__2.ContainsKey(((NPC)<d>5__10).Region))
										{
											<contract>5__3 = <validContracts>5__2[((NPC)<d>5__10).Region];
										}
										if ((Object)(object)<contract>5__3 != (Object)null)
										{
											Dictionary<string, Tuple<Dealer, int>> playerDealerStolen = DealerActivity.playerDealerStolen;
											gUID = ((Quest)<contract>5__3).GUID;
											if (!playerDealerStolen.ContainsKey(((object)(Guid)(ref gUID)).ToString()))
											{
												List<string> consumedGUIDs = DealerActivity.consumedGUIDs;
												gUID = ((Quest)<contract>5__3).GUID;
												if (!consumedGUIDs.Contains(((object)(Guid)(ref gUID)).ToString()))
												{
													<actionTaken>5__11 = true;
													int completionXP = ((Quest)<contract>5__3).CompletionXP;
													((Quest)<contract>5__3).CompletionXP = 0;
													<contract>5__3.completedContractsIncremented = false;
													Dealer dealer = <contract>5__3.Dealer;
													Dictionary<string, Tuple<Dealer, int>> playerDealerStolen2 = DealerActivity.playerDealerStolen;
													gUID = ((Quest)<contract>5__3).GUID;
													playerDealerStolen2.Add(((object)(Guid)(ref gUID)).ToString(), new Tuple<Dealer, int>(dealer, completionXP));
													((Dealer)<d>5__10).AddContract(<contract>5__3);
													((Component)((Dealer)<d>5__10).DealSignal).gameObject.SetActive(true);
												}
											}
										}
									}
									else if (<validCustomers>5__5.Count > 0 && Random.Range(0.01f, 1f) < dealerConfig.StealPlayerPendingChance && dealerConfig.StealPlayerPendingChance != 0f)
									{
										<c>5__12 = <validCustomers>5__5[Random.Range(0, <validCustomers>5__5.Count)];
										if ((Object)(object)<c>5__12.CurrentContract == (Object)null && (Object)(object)<c>5__12.AssignedDealer == (Object)null && <c>5__12.offeredContractInfo != null)
										{
											<contractInfo>5__13 = new ContractInfo();
											<contractInfo>5__13.DeliveryLocation = <c>5__12.offeredContractInfo.DeliveryLocation;
											<contractInfo>5__13.DeliveryLocationGUID = <c>5__12.offeredContractInfo.DeliveryLocationGUID;
											<contractInfo>5__13.Payment = <c>5__12.offeredContractInfo.Payment;
											<contractInfo>5__13.Expires = <c>5__12.offeredContractInfo.Expires;
											<contractInfo>5__13.DeliveryWindow = <c>5__12.offeredContractInfo.DeliveryWindow;
											<contractInfo>5__13.PickupScheduleIndex = <c>5__12.offeredContractInfo.PickupScheduleIndex;
											<contractInfo>5__13.ExpiresAfter = <c>5__12.offeredContractInfo.ExpiresAfter;
											<contractInfo>5__13.IsCounterOffer = <c>5__12.offeredContractInfo.IsCounterOffer;
											<contractInfo>5__13.Products = <c>5__12.offeredContractInfo.Products;
											<c>5__12.ExpireOffer();
											<>2__current = CartelEnforcer.Wait01;
											<>1__state = 5;
											result = true;
											break;
										}
										goto IL_07e0;
									}
									goto IL_07f9;
								}
								if (!((Component)((NPC)<d>5__10).Behaviour.ScheduleManager.ActionList[0]).gameObject.activeSelf)
								{
									((Component)((NPC)<d>5__10).Behaviour.ScheduleManager.ActionList[0]).gameObject.SetActive(true);
								}
							}
							goto IL_0883;
						}
						goto IL_08a4;
					case 5:
					{
						<>1__state = -1;
						if (!CartelEnforcer.registered)
						{
							result = false;
							break;
						}
						<c>5__12.offeredContractInfo = <contractInfo>5__13;
						EDealWindow dealWindow = ((Dealer)<d>5__10).GetDealWindow();
						<contract>5__3 = <c>5__12.ContractAccepted(dealWindow, false, (Dealer)(object)<d>5__10);
						if ((Object)(object)<contract>5__3 != (Object)null)
						{
							((Quest)<contract>5__3).CompletionXP = 0;
							<contract>5__3.completedContractsIncremented = false;
							((Dealer)<d>5__10).AddContract(<contract>5__3);
							((Component)((Dealer)<d>5__10).DealSignal).gameObject.SetActive(true);
							<actionTaken>5__11 = true;
						}
						<contractInfo>5__13 = null;
						goto IL_07e0;
					}
					case 6:
						{
							<>1__state = -1;
							result = false;
							break;
						}
						IL_07e0:
						<validCustomers>5__5.Remove(<c>5__12);
						<c>5__12 = null;
						goto IL_07f9;
						IL_0254:
						if (<i>5__8 < Customer.UnlockedCustomers.Count)
						{
							<>2__current = CartelEnforcer.Wait01;
							<>1__state = 2;
							result = true;
							break;
						}
						<validCustomers>5__5 = new List<Customer>();
						goto IL_0271;
						IL_07f9:
						if (!<actionTaken>5__11 && !((NPC)<d>5__10).isInBuilding && !((NPC)<d>5__10).Movement.HasDestination)
						{
							WalkToInterestPoint(<d>5__10);
						}
						<d>5__10 = null;
						goto IL_0883;
						IL_08a4:
						<>7__wrap8 = null;
						<cList>5__4.Clear();
						<validCustomers>5__5.Clear();
						<validContracts>5__2.Clear();
						<>2__current = null;
						<>1__state = 6;
						result = true;
						break;
						IL_0891:
						if (<i>5__8 < <>7__wrap8.Length)
						{
							<d>5__10 = <>7__wrap8[<i>5__8];
							<contract>5__3 = null;
							<>2__current = CartelEnforcer.Wait2;
							<>1__state = 4;
							result = true;
							break;
						}
						goto IL_08a4;
						IL_01b6:
						if (<>7__wrap5.MoveNext())
						{
							<playerDealer>5__7 = <>7__wrap5.Current;
							<>2__current = CartelEnforcer.Wait01;
							<>1__state = 1;
							result = true;
							break;
						}
						<>m__Finally1();
						<>7__wrap5 = default(List<Dealer>.Enumerator);
						<cList>5__4 = new List<Customer>();
						<i>5__8 = 0;
						goto IL_0254;
						IL_0271:
						<>2__current = CartelEnforcer.Wait01;
						<>1__state = 3;
						result = true;
						break;
						IL_0883:
						<i>5__8++;
						goto IL_0891;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap5).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WalkToInterestPoint>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public WaitForSeconds delay;

			public CartelDealer d;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WalkToInterestPoint>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = delay;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					WalkToInterestPoint(d);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static List<Dealer> allDealers = new List<Dealer>();

		private static CartelDealer[] allCartelDealers;

		public static CartelDealerConfig dealerConfig;

		public static float currentDealerActivity = 0f;

		public static float previousDealerActivity = 0f;

		private static float maxActivity = 1f;

		private static float minActivity = -1f;

		private static int defaultStayInsideStart = 200;

		private static int defaultStayInsideEnd = 2000;

		private static int defaultStayInsideDur = 1080;

		public static int currentStayInsideStart = 0;

		public static int currentStayInsideEnd = 0;

		public static int currentStayInsideDur = 0;

		public static Dictionary<string, Tuple<Dealer, int>> playerDealerStolen = new Dictionary<string, Tuple<Dealer, int>>();

		public static List<string> consumedGUIDs = new List<string>();

		public static Dictionary<NPCEnterableBuilding, StaticDoor> dealerBuildings = new Dictionary<NPCEnterableBuilding, StaticDoor>();

		public static void ParseDealerBuildings()
		{
			CartelDealer[] array = Il2CppArrayBase<CartelDealer>.op_Implicit(Object.FindObjectsOfType<CartelDealer>(true));
			foreach (CartelDealer val in array)
			{
				NPCEvent_StayInBuilding val2 = null;
				if (((NPC)val).Behaviour.ScheduleManager.ActionList != null)
				{
					Enumerator<NPCAction> enumerator = ((NPC)val).Behaviour.ScheduleManager.ActionList.GetEnumerator();
					while (enumerator.MoveNext())
					{
						NPCEvent_StayInBuilding val3 = ((Il2CppObjectBase)enumerator.Current).TryCast<NPCEvent_StayInBuilding>();
						if ((Object)(object)val3 != (Object)null)
						{
							val2 = val3;
						}
					}
				}
				if ((Object)(object)val2 != (Object)null && !dealerBuildings.ContainsKey(val2.Building))
				{
					dealerBuildings.Add(val2.Building, ((Il2CppArrayBase<StaticDoor>)(object)val2.Building.Doors)[0]);
				}
			}
		}

		[IteratorStateMachine(typeof(<EvaluateDealerState>d__17))]
		public static IEnumerator EvaluateDealerState()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EvaluateDealerState>d__17(0);
		}

		public static void ApplyNewEventState(CartelDealer dealer, int inStart, int inEnd, int inDur)
		{
			if ((Object)(object)InterceptEvent.interceptor != (Object)null && (Object)(object)InterceptEvent.interceptor == (Object)(object)dealer)
			{
				return;
			}
			NPCEvent_StayInBuilding val = null;
			if (((NPC)dealer).Behaviour.ScheduleManager.ActionList != null)
			{
				Enumerator<NPCAction> enumerator = ((NPC)dealer).Behaviour.ScheduleManager.ActionList.GetEnumerator();
				while (enumerator.MoveNext())
				{
					NPCEvent_StayInBuilding val2 = ((Il2CppObjectBase)enumerator.Current).TryCast<NPCEvent_StayInBuilding>();
					if ((Object)(object)val2 != (Object)null)
					{
						val = val2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				((NPCAction)val).StartTime = inStart;
				((NPCEvent)val).EndTime = inEnd;
				((NPCEvent)val).Duration = inDur;
			}
		}

		public static void SetupDealers()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			AvatarEquippable component = Object.Instantiate<GameObject>(((Il2CppObjectBase)Resources.Load(dealerConfig.CartelDealerWeapon.ToLower() switch
			{
				"m1911" => "Avatar/Equippables/M1911", 
				"revolver" => "Avatar/Equippables/Revolver", 
				"knife" => "Avatar/Equippables/Knife", 
				"shotgun" => "Avatar/Equippables/PumpShotgun", 
				_ => "Avatar/Equippables/M1911", 
			})).TryCast<GameObject>(), new Vector3(0f, -5f, 0f), Quaternion.identity, (Transform)null).GetComponent<AvatarEquippable>();
			AvatarRangedWeapon val = (AvatarRangedWeapon)(object)((component is AvatarRangedWeapon) ? component : null);
			if (val != null && dealerConfig.CartelDealerLethality > 0f)
			{
				val.Damage = Mathf.Lerp(val.Damage, val.Damage * 2f, dealerConfig.CartelDealerLethality);
				val.AimTime_Max = Mathf.Lerp(val.AimTime_Max, val.AimTime_Max * 0.5f, dealerConfig.CartelDealerLethality);
				val.AimTime_Min = Mathf.Lerp(val.AimTime_Min, val.AimTime_Min * 0.5f, dealerConfig.CartelDealerLethality);
				val.HitChance_MaxRange = Mathf.Lerp(val.HitChance_MaxRange, val.HitChance_MaxRange * 2f, dealerConfig.CartelDealerLethality);
				val.HitChance_MinRange = Mathf.Lerp(val.HitChance_MinRange, val.HitChance_MinRange * 2f, dealerConfig.CartelDealerLethality);
				((AvatarWeapon)val).MaxUseRange = Mathf.Lerp(((AvatarWeapon)val).MaxUseRange, ((AvatarWeapon)val).MaxUseRange * 2f, dealerConfig.CartelDealerLethality);
				((AvatarWeapon)val).MinUseRange = Mathf.Lerp(((AvatarWeapon)val).MinUseRange, ((AvatarWeapon)val).MinUseRange * 0.5f, dealerConfig.CartelDealerLethality);
				val.MaxFireRate = Mathf.Lerp(val.MaxFireRate, val.MaxFireRate * 0.5f, dealerConfig.CartelDealerLethality);
				val.ReloadTime = Mathf.Lerp(val.ReloadTime, val.ReloadTime * 0.5f, dealerConfig.CartelDealerLethality);
			}
			else
			{
				AvatarMeleeWeapon val2 = (AvatarMeleeWeapon)(object)((component is AvatarMeleeWeapon) ? component : null);
				if (val2 != null && dealerConfig.CartelDealerLethality > 0f)
				{
					val2.Damage = Mathf.Lerp(val2.Damage, val2.Damage * 2f, dealerConfig.CartelDealerLethality);
					((AvatarWeapon)val2).CooldownDuration = Mathf.Lerp(((AvatarWeapon)val2).CooldownDuration, ((AvatarWeapon)val2).CooldownDuration * 0.5f, dealerConfig.CartelDealerLethality);
					val2.AttackRange = Mathf.Lerp(val2.AttackRange, val2.AttackRange * 2f, dealerConfig.CartelDealerLethality);
					val2.AttackRadius = Mathf.Lerp(val2.AttackRadius, val2.AttackRadius * 2f, dealerConfig.CartelDealerLethality);
					((AvatarWeapon)val2).MaxUseRange = Mathf.Lerp(((AvatarWeapon)val2).MaxUseRange, ((AvatarWeapon)val2).MaxUseRange * 2f, dealerConfig.CartelDealerLethality);
				}
			}
			CartelDealer[] array = allCartelDealers;
			foreach (CartelDealer dealer in array)
			{
				((NPC)dealer).Movement.WalkSpeed = dealerConfig.CartelDealerWalkSpeed;
				((NPC)dealer).Health.MaxHealth = dealerConfig.CartelDealerHP;
				((NPC)dealer).Health.Health = dealerConfig.CartelDealerHP;
				AvatarWeapon val3 = ((Il2CppObjectBase)component).TryCast<AvatarWeapon>();
				if ((Object)(object)val3 != (Object)null)
				{
					((NPC)dealer).Behaviour.CombatBehaviour.DefaultWeapon = val3;
					component.Equip(((NPC)dealer).Avatar);
				}
				((NPC)dealer).OverrideAggression(1f);
				NPCEvent_StayInBuilding val4 = null;
				NPCSignal_HandleDeal val5 = null;
				if (((NPC)dealer).Behaviour.ScheduleManager.ActionList != null)
				{
					Enumerator<NPCAction> enumerator = ((NPC)dealer).Behaviour.ScheduleManager.ActionList.GetEnumerator();
					while (enumerator.MoveNext())
					{
						NPCAction current = enumerator.Current;
						NPCEvent_StayInBuilding val6 = ((Il2CppObjectBase)current).TryCast<NPCEvent_StayInBuilding>();
						if ((Object)(object)val6 != (Object)null)
						{
							val4 = val6;
							continue;
						}
						NPCSignal_HandleDeal val7 = ((Il2CppObjectBase)current).TryCast<NPCSignal_HandleDeal>();
						if ((Object)(object)val7 != (Object)null)
						{
							val5 = val7;
						}
					}
					if ((Object)(object)val4 != (Object)null)
					{
						((NPCAction)val4).StartTime = defaultStayInsideStart;
						((NPCEvent)val4).EndTime = defaultStayInsideEnd;
						((NPCEvent)val4).Duration = defaultStayInsideDur;
						NPCEvent_StayInBuilding obj = val4;
						((NPCAction)obj).onEnded = ((NPCAction)obj).onEnded + Action.op_Implicit((Action)onStayInsideEnd);
					}
					if ((Object)(object)val5 != (Object)null)
					{
						((NPCSignal)val5).MaxDuration = 60;
						NPCSignal_HandleDeal obj2 = val5;
						((NPCAction)obj2).onEnded = ((NPCAction)obj2).onEnded + Action.op_Implicit((Action)onDealSignalEnd);
					}
				}
				((NPC)dealer).Health.onDieOrKnockedOut.AddListener(UnityAction.op_Implicit((Action)OnDealerDied));
				((NPC)dealer).Health.onDieOrKnockedOut.AddListener(UnityAction.op_Implicit((Action)TrySpawnGoonsOnDeath));
				void TrySpawnGoonsOnDeath()
				{
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//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_00b7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b8: 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_005d: Unknown result type (might be due to invalid IL or missing references)
					//IL_008c: 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_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_009d: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
					if (!(Random.Range(0f, 1f) > 0.5f) && NetworkSingleton<Cartel>.Instance.GoonPool.UnspawnedGoonCount >= 2)
					{
						float num = default(float);
						Player closestPlayer = Player.GetClosestPlayer(((NPC)dealer).CenterPoint, ref num, (List<Player>)null);
						Vector3 val9 = Vector3.zero;
						int num2 = 4;
						int num3 = 0;
						do
						{
							if (!CartelEnforcer.registered)
							{
								return;
							}
							if (num3 == num2)
							{
								break;
							}
							Vector3 onUnitSphere = Random.onUnitSphere;
							onUnitSphere.y = 0f;
							((Vector3)(ref onUnitSphere)).Normalize();
							float num4 = Random.Range(16f, 24f);
							val9 = ((Component)dealer).transform.position + onUnitSphere * num4;
							num3++;
						}
						while (closestPlayer.IsPointVisibleToPlayer(val9, 30f, 5f));
						if (!(val9 == Vector3.zero))
						{
							List<CartelGoon> val10 = NetworkSingleton<Cartel>.Instance.GoonPool.SpawnMultipleGoons(val9, 2, true);
							Enumerator<CartelGoon> enumerator3 = val10.GetEnumerator();
							while (enumerator3.MoveNext())
							{
								CartelGoon current2 = enumerator3.Current;
								((NPC)current2).Movement.WarpToNavMesh();
								if (Random.Range(0f, 1f) > 0.7f && AmbushOverrides.RangedWeapons != null && AmbushOverrides.RangedWeapons.Length != 0)
								{
									((NPC)current2).Behaviour.CombatBehaviour.DefaultWeapon = AmbushOverrides.RangedWeapons[Random.Range(0, AmbushOverrides.RangedWeapons.Length)];
								}
								else if (AmbushOverrides.MeleeWeapons != null && AmbushOverrides.MeleeWeapons.Length != 0)
								{
									((NPC)current2).Behaviour.CombatBehaviour.DefaultWeapon = AmbushOverrides.MeleeWeapons[Random.Range(0, AmbushOverrides.MeleeWeapons.Length)];
								}
								current2.AttackEntity(((Component)closestPlayer).GetComponent<ICombatTargetable>(), true);
							}
							CartelEnforcer.coros.Add(MelonCoroutines.Start(DespawnDefenderGoonsSoon(val10)));
						}
					}
				}
				void onDealSignalEnd()
				{
					//IL_0095: Unknown result type (might be due to invalid IL or missing references)
					//IL_009b: Invalid comparison between Unknown and I4
					if (!InterceptEvent.interceptingDeal || !((Object)(object)InterceptEvent.interceptor != (Object)null) || !((Object)(object)dealer == (Object)(object)InterceptEvent.interceptor))
					{
						if (((Dealer)dealer).ActiveContracts.Count == 0)
						{
							if (!dealer.IsAcceptingDeals)
							{
								dealer.SetIsAcceptingDeals(true);
							}
							CartelEnforcer.coros.Add(MelonCoroutines.Start(WalkToInterestPoint(dealer, CartelEnforcer.Wait2)));
						}
						if (((Dealer)dealer).ActiveContracts.Count > 0 && (int)((Quest)((Dealer)dealer).ActiveContracts[0]).State != 1)
						{
							((Quest)((Dealer)dealer).ActiveContracts[0]).End();
						}
					}
				}
				void onStayInsideEnd()
				{
					if (!InterceptEvent.interceptingDeal || !((Object)(object)InterceptEvent.interceptor != (Object)null) || !((Object)(object)dealer == (Object)(object)InterceptEvent.interceptor))
					{
						if (((Dealer)dealer).ActiveContracts.Count == 0)
						{
							if (!dealer.IsAcceptingDeals)
							{
								dealer.SetIsAcceptingDeals(true);
							}
							CartelEnforcer.coros.Add(MelonCoroutines.Start(WalkToInterestPoint(dealer, CartelEnforcer.Wait5)));
						}
						else
						{
							((Component)((Dealer)dealer).DealSignal).gameObject.SetActive(true);
							if (dealer.IsAcceptingDeals)
							{
								dealer.SetIsAcceptingDeals(false);
							}
						}
					}
				}
			}
			List<CartelDealer> list = new List<CartelDealer>();
			array = allCartelDealers;
			foreach (CartelDealer val8 in array)
			{
				if ((Object)(object)((NPC)val8).Avatar.CurrentSettings == (Object)null)
				{
					list.Add(val8);
				}
			}
			if (list.Count > 0)
			{
				foreach (CartelDealer item in list)
				{
					item.RandomizeAppearance();
				}
			}
			list.Clear();
			list = null;
		}

		[IteratorStateMachine(typeof(<DespawnDefenderGoonsSoon>d__20))]
		public static IEnumerator DespawnDefenderGoonsSoon(List<CartelGoon> goons)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DespawnDefenderGoonsSoon>d__20(0)
			{
				goons = goons
			};
		}

		[IteratorStateMachine(typeof(<StartActiveSignal>d__21))]
		public static IEnumerator StartActiveSignal()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartActiveSignal>d__21(0);
		}

		public static bool IsWalkingEnabled(CartelDealer d)
		{
			if (!CartelEnforcer.currentConfig.enhancedDealers)
			{
				return false;
			}
			if (!dealerConfig.FreeTimeWalking)
			{
				return false;
			}
			if (InterceptEvent.interceptingDeal && (Object)(object)InterceptEvent.interceptor != (Object)null && (Object)(object)InterceptEvent.interceptor == (Object)(object)d)
			{
				return false;
			}
			if (((Dealer)d).ActiveContracts.Count > 0)
			{
				return false;
			}
			if (((NPC)d).Health.IsDead || ((NPC)d).Health.IsKnockedOut)
			{
				return false;
			}
			if (NetworkSingleton<TimeManager>.Instance.CurrentTime < currentStayInsideEnd && NetworkSingleton<TimeManager>.Instance.CurrentTime > currentStayInsideStart)
			{
				return false;
			}
			return true;
		}

		public static void WalkToInterestPoint(CartelDealer d)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected I4, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (!IsWalkingEnabled(d))
			{
				return;
			}
			if (Random.Range(0f, 1f) > 0.5f)
			{
				DeliveryLocation randomUnscheduledDeliveryLocation = ((Il2CppArrayBase<MapRegionData>)(object)Singleton<Map>.instance.Regions)[(int)((NPC)d).Region].GetRandomUnscheduledDeliveryLocation();
				((NPC)d).Movement.SetDestination(randomUnscheduledDeliveryLocation.CustomerStandPoint.position);
			}
			else
			{
				List<DeadDrop> list = new List<DeadDrop>();
				for (int i = 0; i < DeadDrop.DeadDrops.Count; i++)
				{
					if (DeadDrop.DeadDrops[i].Region == ((NPC)d).Region)
					{
						list.Add(DeadDrop.DeadDrops[i]);
					}
				}
				Vector3 position = ((Component)list[Random.Range(0, list.Count)]).transform.position;
				Vector3 val = default(Vector3);
				((NPC)d).Movement.GetClosestReachablePoint(position, ref val);
				if (val != Vector3.zero)
				{
					((NPC)d).Movement.SetDestination(val);
				}
			}
			if (!d.IsAcceptingDeals)
			{
				d.SetIsAcceptingDeals(true);
			}
		}

		[IteratorStateMachine(typeof(<WalkToInterestPoint>d__24))]
		public static IEnumerator WalkToInterestPoint(CartelDealer d, WaitForSeconds delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WalkToInterestPoint>d__24(0)
			{
				d = d,
				delay = delay
			};
		}

		public static void OnDealerDied()
		{
			currentDealerActivity = Mathf.Clamp(currentDealerActivity - dealerConfig.DealerActivityDecreasePerKill, minActivity, maxActivity);
		}

		public static void OnDayPassChange()
		{
			currentDealerActivity = Mathf.Clamp(currentDealerActivity + dealerConfig.DealerActivityIncreasePerDay, minActivity, maxActivity);
		}

		[IteratorStateMachine(typeof(<OnCartelCustomerDeal>d__27))]
		public static IEnumerator OnCartelCustomerDeal(CartelCustomerDeal dealEvent, bool started)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnCartelCustomerDeal>d__27(0)
			{
				dealEvent = dealEvent,
				started = started
			};
		}
	}
	[Serializable]
	public class CartelDealerConfig
	{
		public float CartelDealerWalkSpeed = 2.8f;

		public float CartelDealerHP = 200f;

		public float CartelDealerLethality = 0.5f;

		public string CartelDealerWeapon = "M1911";

		public float StealDealerContractChance = 0.06f;

		public float StealPlayerPendingChance = 0.08f;

		public float DealerActivityDecreasePerKill = 0.1f;

		public float DealerActivityIncreasePerDay = 0.25f;

		public float SafetyThreshold = -0.85f;

		public bool SafetyEnabled = true;

		public bool FreeTimeWalking = true;
	}
	public class CartelRegActivityHours
	{
		public int region;

		public int cartelActivityClass;

		public int hoursUntilEnable;
	}
	public class HrPassParameterMap
	{
		public string itemDesc { get; set; }

		public Func<int> Getter { get; set; }

		public Action<int> Setter { get; set; }

		public Action HourPassAction { get; set; }

		public int modTicksPassed { get; set; }

		public int currentModHours { get; set; }

		public Func<bool> CanPassHour { get; set; }
	}
	public static class FrequencyOverrides
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public CartelActivities instanceActivities;

			public CartelDealManager instanceDealMgr;

			internal int <PopulateParameterMap>b__0()
			{
				return instanceActivities.HoursUntilNextGlobalActivity;
			}

			internal void <PopulateParameterMap>b__1(int value)
			{
				instanceActivities.HoursUntilNextGlobalActivity = value;
			}

			internal void <PopulateParameterMap>b__2()
			{
				instanceActivities.HourPass();
			}

			internal int <PopulateParameterMap>b__9()
			{
				return instanceDealMgr.HoursUntilNextDealRequest;
			}

			internal void <PopulateParameterMap>b__10(int value)
			{
				instanceDealMgr.HoursUntilNextDealRequest = value;
			}

			internal void <PopulateParameterMap>b__11()
			{
				instanceDealMgr.HourPass();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_1
		{
			public CartelRegionActivities act;

			internal int <PopulateParameterMap>b__4()
			{
				return act.HoursUntilNextActivity;
			}

			internal void <PopulateParameterMap>b__5(int value)
			{
				act.HoursUntilNextActivity = value;
			}

			internal void <PopulateParameterMap>b__6()
			{
				act.HourPass();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_2
		{
			public CartelCustomerDeal cartelCustomerDeal;
		}

		[CompilerGenerated]
		private sealed class <HelperSet>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HrPassParameterMap hpmap;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HelperSet>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!hpmap.CanPassHour())
					{
						return false;
					}
					if (!InstanceFinder.IsServer)
					{
						return false;
					}
					if (CartelEnforcer.currentConfig.activityFrequency > 0f)
					{
						hpmap.HourPassAction();
					}
					else
					{
						if (hpmap.Getter() == 1)
						{
							return false;
						}
						float num = Mathf.Lerp(1f, 10f, 0f - CartelEnforcer.currentConfig.activityFrequency);
						if (hpmap.Getter() < hpmap.currentModHours)
						{
							hpmap.Setter(hpmap.currentModHours);
						}
						else
						{
							hpmap.modTicksPassed = 0;
							hpmap.currentModHours = hpmap.Getter();
						}
						hpmap.modTicksPassed++;
						if ((float)hpmap.modTicksPassed >= num)
						{
							hpmap.HourPassAction();
							hpmap.modTicksPassed = 0;
							hpmap.currentModHours -= 1;
						}
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PopulateParameterMap>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass3_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PopulateParameterMap>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_025b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Expected I4, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass3_0();
					<>2__current = CartelEnforcer.Wait2;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					int num = 0;
					<>8__1.instanceActivities = NetworkSingleton<Cartel>.Instance.Activities;
					FrequencyOverrides.actFreqMapping.Add(new HrPassParameterMap
					{
						itemDesc = "Global Activities",
						Getter = () => <>8__1.instanceActivities.HoursUntilNextGlobalActivity,
						Setter = delegate(int value)
						{
							<>8__1.instanceActivities.HoursUntilNextGlobalActivity = value;
						},
						HourPassAction = delegate
						{
							<>8__1.instanceActivities.HourPass();
						},
						modTicksPassed = 0,
						currentModHours = <>8__1.instanceActivities.HoursUntilNextGlobalActivity,
						CanPassHour = () => (int)NetworkSingleton<Cartel>.Instance.Status == 2
					});
					num++;
					CartelRegActivityHours item = new CartelRegActivityHours
					{
						region = -1,
						hoursUntilEnable = GetActivityHours(CartelEnforcer.currentConfig.ambushFrequency),
						cartelActivityClass = -1
					};
					regActivityHours.Add(item);
					CartelRegionActivities[] array = Il2CppArrayBase<CartelRegionActivities>.op_Implicit((Il2CppArrayBase<CartelRegionActivities>)(object)NetworkSingleton<Cartel>.Instance.Activities.RegionalActivities);
					for (int i = 0; i < array.Length; i++)
					{
						<>c__DisplayClass3_1 CS$<>8__locals1 = new <>c__DisplayClass3_1
						{
							act = array[i]
						};
						List<HrPassParameterMap> actFreqMapping = FrequencyOverrides.actFreqMapping;
						HrPassParameterMap hrPassParameterMap = new HrPassParameterMap();
						EMapRegion region = CS$<>8__locals1.act.Region;
						hrPassParameterMap.itemDesc = "Cartel Regional Activities (" + ((object)(EMapRegion)(ref region)).ToString() + ")";
						hrPassParameterMap.Getter = () => CS$<>8__locals1.act.HoursUntilNextActivity;
						hrPassParameterMap.Setter = delegate(int value)
						{
							CS$<>8__locals1.act.HoursUntilNextActivity = value;
						};
						hrPassParameterMap.HourPassAction = delegate
						{
							CS$<>8__locals1.act.HourPass();
						};
						hrPassParameterMap.modTicksPassed = 0;
						hrPassParameterMap.currentModHours = CS$<>8__locals1.act.HoursUntilNextActivity;
						hrPassParameterMap.CanPassHour = () => (int)NetworkSingleton<Cartel>.Instance.Status == 2;
						actFreqMapping.Add(hrPassParameterMap);
						num++;
						Enumerator<CartelActivity> enumerator = CS$<>8__locals1.act.Activities.GetEnumerator();
						while (enumerator.MoveNext())
						{
							CartelActivity current = enumerator.Current;
							CartelRegActivityHours cartelRegActivityHours = new CartelRegActivityHours
							{
								region = (int)CS$<>8__locals1.act.Region
							};
							int num2 = 0;
							<>c__DisplayClass3_2 CS$<>8__locals0;
							if ((Object)(object)((Il2CppObjectBase)current).TryCast<StealDeadDrop>() != (Object)null)
							{
								cartelRegActivityHours.cartelActivityClass = 0;
								num2 = GetActivityHours(CartelEnforcer.currentConfig.deadDropStealFrequency);
							}
							else if ((Object)(object)((Il2CppObjectBase)current).TryCast<CartelCustomerDeal>() != (Object)null)
							{
								cartelRegActivityHours.cartelActivityClass = 1;
								num2 = GetActivityHours(CartelEnforcer.currentConfig.cartelCustomerDealFrequency);
								if (CartelEnforcer.currentConfig.enhancedDealers)
								{
									CS$<>8__locals0 = new <>c__DisplayClass3_2
									{
										cartelCustomerDeal = ((Il2CppObjectBase)current).TryCast<CartelCustomerDeal>()
									};
									CartelCustomerDeal cartelCustomerDeal = CS$<>8__locals0.cartelCustomerDeal;
									((CartelActivity)cartelCustomerDeal).onActivated = ((CartelActivity)cartelCustomerDeal).onActivated + Action.op_Implicit((Action)OnCustomerDealActive);
								}
							}
							else
							{
								if (!((Object)(object)((Il2CppObjectBase)current).TryCast<RobDealer>() != (Object)null))
								{
									continue;
								}
								cartelRegActivityHours.cartelActivityClass = 2;
								num2 = GetActivityHours(CartelEnforcer.currentConfig.cartelRobberyFrequency);
							}
							cartelRegActivityHours.hoursUntilEnable = num2;
							regActivityHours.Add(cartelRegActivityHours);
							void OnCustomerDealActive()
							{
								CartelEnforcer.coros.Add(MelonCoroutines.Start(DealerActivity.OnCartelCustomerDeal(CS$<>8__locals0.cartelCustomerDeal, started: true)));
							}
						}
					}
					<>8__1.instanceDealMgr = NetworkSingleton<Cartel>.Instance.DealManager;
					FrequencyOverrides.actFreqMapping.Add(new HrPassParameterMap
					{
						itemDesc = "Cartel Deal Manager (Truced only)",
						Getter = () => <>8__1.instanceDealMgr.HoursUntilNextDealRequest,
						Setter = delegate(int value)
						{
							<>8__1.instanceDealMgr.HoursUntilNextDealRequest = value;
						},
						HourPassAction = delegate
						{
							<>8__1.instanceDealMgr.HourPass();
						},
						modTicksPassed = 0,
						currentModHours = <>8__1.instanceDealMgr.HoursUntilNextDealRequest,
						CanPassHour = () => (int)NetworkSingleton<Cartel>.Instance.Status == 1
					});
					num++;
					FrequencyOverrides.actFreqMapping.Add(new HrPassParameterMap
					{
						itemDesc = "Drive-By Events",
						Getter = () => DriveByEvent.hoursUntilDriveBy,
						Setter = delegate(int value)
						{
							DriveByEvent.hoursUntilDriveBy = value;
						},
						HourPassAction = delegate
						{
							DriveByEvent.hoursUntilDriveBy = Mathf.Clamp(DriveByEvent.hoursUntilDriveBy - 1, 0, 48);
						},
						modTicksPassed = 0,
						currentModHours = DriveByEvent.hoursUntilDriveBy,
						CanPassHour = () => (int)NetworkSingleton<Cartel>.Instance.Status == 2
					});
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <TickOverrideHourPass>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private WaitForSeconds <WaitCalculated>5__2;

			private List<HrPassParameterMap>.Enumerator <>7__wrap2;

			private HrPassParameterMap <item>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TickOverrideHourPass>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<WaitCalculated>5__2 = null;
				<>7__wrap2 = default(List<HrPassParameterMap>.Enumerator);
				<item>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>2__current = CartelEnforcer.Wait5;
						<>1__state = 1;
						result = true;
						break;
					case 1:
					{
						<>1__state = -1;
						if (!CartelEnforcer.registered)
						{
							result = false;
							break;
						}
						if (CartelEnforcer.currentConfig.activityFrequency == 0f)
						{
							result = false;
							break;
						}
						float num = 60f;
						float num2 = 60f;
						if (CartelEnforcer.currentConfig.activityFrequency > 0f)
						{
							num2 = Mathf.Lerp(num, num / 10f, CartelEnforcer.currentConfig.activityFrequency);
						}
						<WaitCalculated>5__2 = new WaitForSeconds(num2 / (float)actFreqMapping.Count);
						goto IL_0179;
					}
					case 2:
						<>1__state = -3;
						if (!CartelEnforcer.registered)
						{
							result = false;
							<>m__Finally1();
							break;
						}
						MelonCoroutines.Start(HelperSet(<item>5__4));
						<item>5__4 = null;
						goto IL_0150;
					case 3:
						{
							<>1__state = -1;
							result = false;
							break;
						}
						IL_0179:
						while (true)
						{
							if (CartelEnforcer.registered)
							{
								if (!CartelEnforcer.registered)
								{
									result = false;
									break;
								}
								if (actFreqMapping.Count == 0)
								{
									continue;
								}
								<>7__wrap2 = actFreqMapping.GetEnumerator();
								<>1__state = -3;
								goto IL_0150;
							}
							<>2__current = null;
							<>1__state = 3;
							result = true;
							break;
						}
						break;
						IL_0150:
						if (<>7__wrap2.MoveNext())
						{
							<item>5__4 = <>7__wrap2.Current;
							<>2__current = <WaitCalculated>5__2;
							<>1__state = 2;
							result = true;
							break;
						}
						<>m__Finally1();
						<>7__wrap2 = default(List<HrPassParameterMap>.Enumerator);
						goto IL_0179;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap2).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static List<HrPassParameterMap> actFreqMapping = new List<HrPassParameterMap>();

		public static List<CartelRegActivityHours> regActivityHours = new List<CartelRegActivityHours>();

		public static int GetActivityHours(float configValue)
		{
			int num = 0;
			if (configValue > 0f)
			{
				int num2 = 1;
				return Mathf.RoundToInt(Mathf.Lerp(48f, (float)num2, configValue));
			}
			if (configValue < 0f)
			{
				int num3 = 96;
				float num4 = 0f - configValue;
				return Mathf.RoundToInt(Mathf.Lerp(48f, (float)num3, num4));
			}
			return 48;
		}

		[IteratorStateMachine(typeof(<PopulateParameterMap>d__3))]
		public static IEnumerator PopulateParameterMap()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PopulateParameterMap>d__3(0);
		}

		public static void OnHourPassReduceCartelRegActHours()
		{
			if (regActivityHours.Count <= 0)
			{
				return;
			}
			foreach (CartelRegActivityHours regActivityHour in regActivityHours)
			{
				if (regActivityHour.hoursUntilEnable > 0)
				{
					regActivityHour.hoursUntilEnable--;
				}
			}
		}

		[IteratorStateMachine(typeof(<TickOverrideHourPass>d__5))]
		public static IEnumerator TickOverrideHourPass()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TickOverrideHourPass>d__5(0);
		}

		[IteratorStateMachine(typeof(<HelperSet>d__6))]
		public static IEnumerator HelperSet(HrPassParameterMap hpmap)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HelperSet>d__6(0)
			{
				hpmap = hpmap
			};
		}
	}
	[HarmonyPatch(typeof(CartelActivities), "TryStartActivity")]
	public static class CartelActivities_TryStartActivityPatch
	{
		public static List<CartelActivity> activitiesReadyToStart = new List<CartelActivity>();

		public static List<EMapRegion> validRegionsForActivity = new List<EMapRegion>();

		[HarmonyPrefix]
		public static bool Prefix(CartelActivities __instance)
		{
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			__instance.HoursUntilNextGlobalActivity = CartelActivities.GetNewCooldown();
			if (!__instance.CanNewActivityBegin())
			{
				return false;
			}
			Enumerator<CartelActivity> enumerator = __instance.GetActivitiesReadyToStart().GetEnumerator();
			while (enumerator.MoveNext())
			{
				CartelActivity current = enumerator.Current;
				activitiesReadyToStart.Add(current);
			}
			Enumerator<EMapRegion> enumerator2 = __instance.GetValidRegionsForActivity().GetEnumerator();
			while (enumerator2.MoveNext())
			{
				EMapRegion current2 = enumerator2.Current;
				validRegionsForActivity.Add(current2);
			}
			if (activitiesReadyToStart.Count == 0 || validRegionsForActivity.Count == 0)
			{
				return false;
			}
			validRegionsForActivity.Sort((EMapRegion a, EMapRegion b) => NetworkSingleton<Cartel>.Instance.Influence.GetInfluence(b).CompareTo(NetworkSingleton<Cartel>.Instance.Influence.GetInfluence(a)));
			EMapRegion val = (EMapRegion)0;
			bool flag = false;
			foreach (EMapRegion item in validRegionsForActivity)
			{
				float influence = NetworkSingleton<Cartel>.Instance.Influence.GetInfluence(item);
				float num = 0f;
				float num2 = 0f;
				if (CartelEnforcer.currentConfig.activityInfluenceMin == 0f)
				{
					num = 0.7f;
					num2 = influence * num;
					if (Random.Range(0f, 1f) < num2)
					{
						val = item;
						flag = true;
						break;
					}
					continue;
				}
				if (CartelEnforcer.currentConfig.activityInfluenceMin > 0f)
				{
					num2 = Mathf.Lerp(influence * 0.7f, 1f, CartelEnforcer.currentConfig.activityInfluenceMin);
					if (Random.Range(0f, 1f) > num2)
					{
						val = item;
						flag = true;
						break;
					}
					continue;
				}
				_ = CartelEnforcer.currentConfig.activityInfluenceMin;
				num = Mathf.Lerp(1f, 0f, CartelEnforcer.currentConfig.activityInfluenceMin);
				num2 = influence * num;
				if (Random.Range(0f, 1f) > num2)
				{
					val = item;
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return false;
			}
			if (FrequencyOverrides.regActivityHours[0].hoursUntilEnable > 0)
			{
				return false;
			}
			int count = activitiesReadyToStart.Count;
			do
			{
				count = activitiesReadyToStart.Count;
				if (count == 0)
				{
					break;
				}
				int index = Random.Range(0, count);
				if (activitiesReadyToStart[index].IsRegionValidForActivity(val))
				{
					NetworkSingleton<Cartel>.Instance.Activities.StartGlobalActivity((NetworkConnection)null, val, 0);
					FrequencyOverrides.regActivityHours[0].hoursUntilEnable = FrequencyOverrides.GetActivityHours(CartelEnforcer.currentConfig.ambushFrequency);
					break;
				}
				activitiesReadyToStart.Remove(activitiesReadyToStart[index]);
			}
			while (count != 0);
			activitiesReadyToStart.Clear();
			validRegionsForActivity.Clear();
			return false;
		}
	}
	[HarmonyPatch(typeof(CartelRegionActivities), "TryStartActivity")]
	public static class CartelRegionActivities_TryStartActivityPatch
	{
		public static Dictionary<CartelActivity, List<int>> enabledActivities = new Dictionary<CartelActivity, List<int>>();

		[HarmonyPrefix]
		public static bool Prefix(CartelRegionActivities __instance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between I4 and Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			__instance.HoursUntilNextActivity = CartelRegionActivities.GetNewCooldown(__instance.Region);
			List<int> list = new List<int>();
			for (int i = 0; i < FrequencyOverrides.regActivityHours.Count; i++)
			{
				if (FrequencyOverrides.regActivityHours[i].region == (int)__instance.Region)
				{
					list.Add(i);
				}
			}
			Enumerator<CartelActivity> enumerator = __instance.Activities.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CartelActivity current = enumerator.Current;
				int num = 0;
				num = ((!((Object)(object)((Il2CppObjectBase)current).TryCast<StealDeadDrop>() != (Object)null)) ? (((Object)(object)((Il2CppObjectBase)current).TryCast<CartelCustomerDeal>() != (Object)null) ? 1 : 2) : 0);
				for (int j = 0; j < list.Count; j++)
				{
					if (FrequencyOverrides.regActivityHours[list[j]].cartelActivityClass == num && FrequencyOverrides.regActivityHours[list[j]].hoursUntilEnable <= 0 && !enabledActivities.ContainsKey(current))
					{
						List<int> value = new List<int>
						{
							list[j],
							num
						};
						enabledActivities.Add(current, value);
					}
				}
			}
			if (enabledActivities.Count == 0)
			{
				enabledActivities.Clear();
				return false;
			}
			int count = enabledActivities.Count;
			do
			{
				count = enabledActivities.Count;
				if (count == 0)
				{
					break;
				}
				KeyValuePair<CartelActivity, List<int>> keyValuePair = enabledActivities.ElementAt(Random.Range(0, count));
				if (keyValuePair.Key.IsRegionValidForActivity(__instance.Region))
				{
					__instance.StartActivity((NetworkConnection)null, __instance.Activities.IndexOf(keyValuePair.Key));
					if (keyValuePair.Value[1] == 0)
					{
						FrequencyOverrides.regActivityHours[keyValuePair.Value[0]].hoursUntilEnable = FrequencyOverrides.GetActivityHours(CartelEnforcer.currentConfig.deadDropStealFrequency);
					}
					else if (keyValuePair.Value[1] == 1)
					{
						FrequencyOverrides.regActivityHours[keyValuePair.Value[0]].hoursUntilEnable = FrequencyOverrides.GetActivityHours(CartelEnforcer.currentConfig.cartelCustomerDealFrequency);
					}
					else if (keyValuePair.Value[1] == 2)
					{
						FrequencyOverrides.regActivityHours[keyValuePair.Value[0]].hoursUntilEnable = FrequencyOverrides.GetActivityHours(CartelEnforcer.currentConfig.cartelRobberyFrequency);
					}
					break;
				}
				enabledActivities.Remove(keyValuePair.Key);
			}
			while (count != 0);
			enabledActivities.Clear();
			return false;
		}
	}
	public static class InfluenceOverrides
	{
		[CompilerGenerated]
		private sealed class <ApplyInfluenceConfig>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyInfluenceConfig>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CartelEnforcer.Wait2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					if (CartelEnforcer.currentConfig.activityInfluenceMin != 0f)
					{
						Enumerator<CartelActivity> enumerator = NetworkSingleton<Cartel>.Instance.Activities.GlobalActivities.GetEnumerator();
						while (enumerator.MoveNext())
						{
							CartelActivity current = enumerator.Current;
							float num = 0f;
							num = ((!(CartelEnforcer.currentConfig.activityInfluenceMin > 0f) || !(current.InfluenceRequirement > 0f)) ? Mathf.Lerp(current.InfluenceRequirement, 0f, 0f - CartelEnforcer.currentConfig.activityInfluenceMin) : Mathf.Lerp(current.InfluenceRequirement, 1f, CartelEnforcer.currentConfig.activityInfluenceMin));
							current.InfluenceRequirement = num;
						}
						CartelRegionActivities[] array = Il2CppArrayBase<CartelRegionActivities>.op_Implicit(Object.FindObjectsOfType<CartelRegionActivities>(true));
						for (int i = 0; i < array.Length; i++)
						{
							enumerator = array[i].Activities.GetEnumerator();
							while (enumerator.MoveNext())
							{
								CartelActivity current2 = enumerator.Current;
								float num2 = 0f;
								num2 = ((!(CartelEnforcer.currentConfig.activityInfluenceMin > 0f) || !(current2.InfluenceRequirement > 0f)) ? Mathf.Lerp(current2.InfluenceRequirement, 0f, 0f - CartelEnforcer.currentConfig.activityInfluenceMin) : Mathf.Lerp(current2.InfluenceRequirement, 1f, CartelEnforcer.currentConfig.activityInfluenceMin));
								current2.InfluenceRequirement = num2;
							}
						}
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <OnDayChangeApplyPassiveGain>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private IEnumerator<MapRegionData> <>7__wrap1;

			private MapRegionData <region>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnDayChangeApplyPassiveGain>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<region>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = ((Il2CppArrayBase<MapRegionData>)(object)Singleton<Map>.Instance.Regions).GetEnumerator();
						<>1__state = -3;
						goto IL_00bb;
					case 1:
						<>1__state = -3;
						if (ShouldChangeInfluence(<region>5__3.Region))
						{
							NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(<region>5__3.Region, -0.02f + CartelEnforcer.influenceConfig.passiveInfluenceGainPerDay);
						}
						<region>5__3 = null;
						goto IL_00bb;
					case 2:
						{
							<>1__state = -1;
							return false;
						}
						IL_00bb:
						if (<>7__wrap1.MoveNext())
						{
							<region>5__3 = <>7__wrap1.Current;
							<>2__current = CartelEnforcer.Wait05;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = null;
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool ShouldChangeInfluence(EMapRegion region)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
			{
				result = false;
			}
			Enumerator<EMapRegion> enumerator = Singleton<Map>.Instance.GetUnlockedRegions().GetEnumerator();
			while (enumerator.MoveNext())
			{
				if (enumerator.Current == region && InstanceFinder.IsServer)
				{
					result = true;
					break;
				}
			}
			if ((int)region == 0)
			{
				result = false;
			}
			return result;
		}

		[IteratorStateMachine(typeof(<ApplyInfluenceConfig>d__1))]
		public static IEnumerator ApplyInfluenceConfig()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyInfluenceConfig>d__1(0);
		}

		[IteratorStateMachine(typeof(<OnDayChangeApplyPassiveGain>d__2))]
		public static IEnumerator OnDayChangeApplyPassiveGain()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnDayChangeApplyPassiveGain>d__2(0);
		}

		public static void OnDayPassChangePassive()
		{
			CartelEnforcer.coros.Add(MelonCoroutines.Start(OnDayChangeApplyPassiveGain()));
		}
	}
	[Serializable]
	public class InfluenceConfig
	{
		public float interceptFail = 0.025f;

		public float interceptSuccess = -0.05f;

		public float deadDropFail = 0.025f;

		public float deadDropSuccess = -0.05f;

		public float gatheringFail = 0.025f;

		public float gatheringSuccess = -0.08f;

		public float robberyPlayerEscape = 0.025f;

		public float robberyGoonEscapeSuccess = 0.025f;

		public float robberyGoonDead = -0.08f;

		public float robberyGoonEscapeDead = -0.05f;

		public float sabotageBombDefused = -0.15f;

		public float sabotageGoonKilled = -0.05f;

		public float sabotageBombExploded = 0.2f;

		public float passiveInfluenceGainPerDay = 0.025f;

		public float cartelDealerDied = -0.1f;

		public float ambushDefeated = -0.1f;

		public float graffitiInfluenceReduction = -0.05f;

		public float customerUnlockInfluenceChange = -0.075f;
	}
	[HarmonyPatch(typeof(CartelDealer), "DiedOrKnockedOut")]
	public static class CartelDealer_Died_Patch
	{
		public static bool Prefix(CartelDealer __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!InstanceFinder.IsServer)
			{
				return false;
			}
			if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
			{
				return false;
			}
			NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(((NPC)__instance).Region, CartelEnforcer.influenceConfig.cartelDealerDied);
			return false;
		}
	}
	[HarmonyPatch(typeof(Ambush), "SpawnAmbush")]
	public static class Ambush_SpawnAmbush_Patch
	{
		[CompilerGenerated]
		private sealed class <OverMonitorAmbush>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<CartelGoon> currentlySpawned;

			public EMapRegion region;

			private float <preMaxElapsed>5__2;

			private float <preElapsed>5__3;

			private List<CartelGoon> <ambushSpawned>5__4;

			private float <maxAmbushElapsed>5__5;

			private float <elapsed>5__6;

			private List<CartelGoon> <deadGoons>5__7;

			private int <spawnedCount>5__8;

			private List<CartelGoon>.Enumerator <>7__wrap8;

			private CartelGoon <goon>5__10;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OverMonitorAmbush>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<ambushSpawned>5__4 = null;
				<deadGoons>5__7 = null;
				<>7__wrap8 = default(List<CartelGoon>.Enumerator);
				<goon>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_036c: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<preMaxElapsed>5__2 = 1f;
						<preElapsed>5__3 = 0f;
						<ambushSpawned>5__4 = new List<CartelGoon>();
						goto IL_00ff;
					case 1:
						<>1__state = -1;
						<preElapsed>5__3 += 0.25f;
						if (NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons.Count != currentlySpawned.Count)
						{
							Enumerator<CartelGoon> enumerator = NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons.GetEnumerator();
							while (enumerator.MoveNext())
							{
								CartelGoon current = enumerator.Current;
								if (!currentlySpawned.Contains(current) && !<ambushSpawned>5__4.Contains(current) && !CartelGathering.spawnedGatherGoons.Contains(current))
								{
									<ambushSpawned>5__4.Add(current);
								}
							}
						}
						goto IL_00ff;
					case 2:
						<>1__state = -3;
						<elapsed>5__6 += 0.5f;
						if (!<deadGoons>5__7.Contains(<goon>5__10))
						{
							if (((NPC)<goon>5__10).Health.IsDead || ((NPC)<goon>5__10).Health.IsKnockedOut)
							{
								<deadGoons>5__7.Add(<goon>5__10);
							}
							<goon>5__10 = null;
						}
						goto IL_023a;
					case 3:
						{
							<>1__state = -4;
							<elapsed>5__6 += 0.5f;
							if (<ambushSpawned>5__4.Contains(<goon>5__10))
							{
								<ambushSpawned>5__4.Remove(<goon>5__10);
							}
							<goon>5__10 = null;
							goto IL_02e7;
						}
						IL_023a:
						if (<>7__wrap8.MoveNext())
						{
							<goon>5__10 = <>7__wrap8.Current;
							<>2__current = CartelEnforcer.Wait05;
							<>1__state = 2;
							return true;
						}
						<>m__Finally1();
						<>7__wrap8 = default(List<CartelGoon>.Enumerator);
						<>7__wrap8 = <deadGoons>5__7.GetEnumerator();
						<>1__state = -4;
						goto IL_02e7;
						IL_02e7:
						if (<>7__wrap8.MoveNext())
						{
							<goon>5__10 = <>7__wrap8.Current;
							<>2__current = CartelEnforcer.Wait05;
							<>1__state = 3;
							return true;
						}
						<>m__Finally2();
						<>7__wrap8 = default(List<CartelGoon>.Enumerator);
						goto IL_0306;
						IL_0306:
						if (!CartelEnforcer.registered || !(<elapsed>5__6 < <maxAmbushElapsed>5__5) || <ambushSpawned>5__4.Count == 0 || <deadGoons>5__7.Count == <spawnedCount>5__8)
						{
							break;
						}
						<>7__wrap8 = <ambushSpawned>5__4.GetEnumerator();
						<>1__state = -3;
						goto IL_023a;
						IL_00ff:
						if (CartelEnforcer.registered && <preElapsed>5__3 < <preMaxElapsed>5__2)
						{
							<>2__current = CartelEnforcer.Wait025;
							<>1__state = 1;
							return true;
						}
						if (<ambushSpawned>5__4.Count == 0)
						{
							return false;
						}
						<maxAmbushElapsed>5__5 = Ambush.CANCEL_AMBUSH_AFTER_MINS;
						<elapsed>5__6 = 0f;
						<deadGoons>5__7 = new List<CartelGoon>();
						<spawnedCount>5__8 = <ambushSpawned>5__4.Count;
						goto IL_0306;
					}
					if ((<ambushSpawned>5__4.Count == 0 || <deadGoons>5__7.Count == <spawnedCount>5__8) && InstanceFinder.IsServer)
					{
						float num = 0f - Ambush.AMBUSH_DEFEATED_INFLUENCE_CHANGE + CartelEnforcer.influenceConfig.ambushDefeated;
						if (num != 0f)
						{
							NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(region, num);
						}
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap8).Dispose();
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap8).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool Prefix(Ambush __instance, Player target, Vector3[] potentialSpawnPoints)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			List<CartelGoon> spawnedGoons = NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons;
			List<CartelGoon> list = new List<CartelGoon>(spawnedGoons.Count);
			Enumerator<CartelGoon> enumerator = spawnedGoons.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CartelGoon current = enumerator.Current;
				list.Add(current);
			}
			List<CartelGoon> currentlySpawned = list;
			CartelEnforcer.coros.Add(MelonCoroutines.Start(OverMonitorAmbush(potentialSpawnPoints, currentlySpawned, ((CartelActivity)__instance).Region)));
			return true;
		}

		[IteratorStateMachine(typeof(<OverMonitorAmbush>d__1))]
		public static IEnumerator OverMonitorAmbush(Vector3[] potentialSpawnPoints, List<CartelGoon> currentlySpawned, EMapRegion region)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OverMonitorAmbush>d__1(0)
			{
				currentlySpawned = currentlySpawned,
				region = region
			};
		}
	}
	[HarmonyPatch(typeof(SpraySurfaceInteraction), "Reward")]
	public static class SpraySurfaceInteraction_Reward_Patch
	{
		public static bool Prefix(SpraySurfaceInteraction __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			NetworkSingleton<LevelManager>.Instance.AddXP(50);
			if (!InstanceFinder.IsServer)
			{
				return false;
			}
			if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
			{
				return false;
			}
			NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(__instance.SpraySurface.Region, CartelEnforcer.influenceConfig.graffitiInfluenceReduction);
			return false;
		}
	}
	[HarmonyPatch(typeof(CartelInfluence), "ChangeInfluence", new Type[]
	{
		typeof(EMapRegion),
		typeof(float),
		typeof(float)
	})]
	public static class CartelInfluence_ChangeInfluence_ObserverRPC_Patch
	{
		public static bool Prefix(CartelInfluence __instance, EMapRegion region, float oldInfluence, float newInfluence)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!Singleton<Map>.Instance.GetUnlockedRegions().Contains(region))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CartelInfluence), "ChangeInfluence", new Type[]
	{
		typeof(EMapRegion),
		typeof(float)
	})]
	public static class CartelInfluence_ChangeInfluence_ServerRPC_Patch
	{
		public static bool Prefix(CartelInfluence __instance, EMapRegion region, float amount)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!Singleton<Map>.Instance.GetUnlockedRegions().Contains(region))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Customer), "OnCustomerUnlocked")]
	public static class Customer_OnCustomerUnlocked_Patch
	{
		public static bool Prefix(Customer __instance, EUnlockType unlockType, bool notify)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!notify || !NetworkSingleton<Cartel>.InstanceExists)
			{
				return true;
			}
			if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
			{
				return true;
			}
			float num = 0f - Customer.CUSTOMER_UNLOCKED_CARTEL_INFLUENCE_CHANGE + CartelEnforcer.influenceConfig.customerUnlockInfluenceChange;
			if (num != 0f)
			{
				NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(__instance.NPC.Region, num);
			}
			return true;
		}
	}
	[Serializable]
	public class NewAmbushConfig
	{
		public int mapRegion;

		public Vector3 ambushPosition = Vector3.zero;

		public List<Vector3> spawnPoints = new List<Vector3>();

		public float detectionRadius = 10f;
	}
	[Serializable]
	public class ListNewAmbush
	{
		public List<NewAmbushConfig> addedAmbushes = new List<NewAmbushConfig>();
	}
	[Serializable]
	public class AmbushGeneralSettingsSerialized
	{
		public List<string> RangedWeaponAssetPaths;

		public List<string> MeleeWeaponAssetPaths;

		public int MinRankForRanged = 2;

		public bool AfterDealAmbushEnabled = true;
	}
	public static class AmbushOverrides
	{
		[HarmonyPatch(typeof(Ambush), "ContractReceiptRecorded")]
		public static class Ambush_ContractReceiptRecorded_Patch
		{
			[HarmonyPrefix]
			public static bool Prefix(Ambush __instance, ContractReceipt receipt)
			{
				return ambushSettings.AfterDealAmbushEnabled;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass6_0
		{
			public NewAmbushConfig config;

			internal bool <AddUserModdedAmbush>b__0(CartelRegionActivities act)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Invalid comparison between Unknown and I4
				return (int)act.Region == config.mapRegion;
			}
		}

		[CompilerGenerated]
		private sealed class <AddUserModdedAmbush>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AddUserModdedAmbush>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ff: Unknown result type (might be due to i