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 System.Security;
using System.Security.Permissions;
using CartelEnforcer;
using FishNet;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Managing.Object;
using FishNet.Object;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using ScheduleOne;
using ScheduleOne.AvatarFramework;
using ScheduleOne.AvatarFramework.Equipping;
using ScheduleOne.Cartel;
using ScheduleOne.Combat;
using ScheduleOne.DevUtilities;
using ScheduleOne.Dialogue;
using ScheduleOne.Doors;
using ScheduleOne.Economy;
using ScheduleOne.GameTime;
using ScheduleOne.Graffiti;
using ScheduleOne.Interaction;
using ScheduleOne.ItemFramework;
using ScheduleOne.Law;
using ScheduleOne.Levelling;
using ScheduleOne.Lighting;
using ScheduleOne.Map;
using ScheduleOne.Messaging;
using ScheduleOne.Misc;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.Behaviour;
using ScheduleOne.NPCs.CharacterClasses;
using ScheduleOne.NPCs.Other;
using ScheduleOne.NPCs.Relation;
using ScheduleOne.NPCs.Schedules;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Packaging;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.Police;
using ScheduleOne.Product;
using ScheduleOne.Product.Packaging;
using ScheduleOne.Property;
using ScheduleOne.Quests;
using ScheduleOne.Storage;
using ScheduleOne.UI;
using ScheduleOne.UI.Handover;
using ScheduleOne.UI.MainMenu;
using ScheduleOne.UI.Phone.Messages;
using ScheduleOne.Vehicles;
using ScheduleOne.Vehicles.AI;
using ScheduleOne.VoiceOver;
using TMPro;
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: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[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")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/XOWithSauce/schedule-cartelenforcer")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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
				if ((int)__instance.DealerType == 1)
				{
					foreach (Contract activeContract in __instance.ActiveContracts)
					{
						if (!playerDealerStolen.ContainsKey(((Quest)activeContract).GUID.ToString()))
						{
							((Quest)activeContract).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_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)
				if (handoverByPlayer)
				{
					return true;
				}
				if ((Object)(object)contract.Dealer == (Object)null)
				{
					return true;
				}
				if (!playerDealerStolen.ContainsKey(((Quest)contract).GUID.ToString()))
				{
					return true;
				}
				playerDealerStolen.TryGetValue(((Quest)contract).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);
				}
				playerDealerStolen.Remove(((Quest)contract).GUID.ToString());
				consumedGUIDs.Add(((Quest)contract).GUID.ToString());
				return true;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__OnDealerDied;
		}

		[CompilerGenerated]
		private sealed class <DespawnDefenderGoonsSoon>d__20 : IEnumerator<object>, IDisposable, IEnumerator
		{
			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()
			{
				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_00fd;
				case 1:
					<>1__state = -1;
					foreach (CartelGoon goon in goons)
					{
						if ((((NPC)goon).Health.IsDead || ((NPC)goon).Health.IsKnockedOut) && goon.IsGoonSpawned)
						{
							<goonsDead>5__3++;
							((NPC)goon).Health.Revive();
							goon.Despawn();
							((Behaviour)((NPC)goon).Behaviour.CombatBehaviour).Disable_Networked((NetworkConnection)null);
						}
					}
					if (<goonsDead>5__3 != goons.Count)
					{
						<i>5__4++;
						goto IL_00fd;
					}
					goto IL_010e;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_010e:
					foreach (CartelGoon goon2 in goons)
					{
						if (goon2.IsGoonSpawned)
						{
							goon2.Despawn();
							((Behaviour)((NPC)goon2).Behaviour.CombatBehaviour).Disable_Networked((NetworkConnection)null);
						}
					}
					<>2__current = null;
					<>1__state = 2;
					return true;
					IL_00fd:
					if (<i>5__4 < <maxHoursWaited>5__2)
					{
						<>2__current = CartelEnforcer.Wait60;
						<>1__state = 1;
						return true;
					}
					goto IL_010e;
				}
			}

			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>, IDisposable, IEnumerator
		{
			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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: 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 = Object.FindObjectsOfType<CartelDealer>(true);
					Dealer[] array = 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)Delegate.Combine(instance.onDayPass, new Action(OnDayPassChange));
					goto IL_0524;
				}
				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_02f7;
						}
						goto IL_030e;
					}
					goto IL_0524;
				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_02f7;
				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_03cf;
				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_04b0;
				case 6:
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					goto IL_0524;
				case 7:
					{
						<>1__state = -1;
						return false;
					}
					IL_030e:
					previousDealerActivity = currentDealerActivity;
					<safetyThresholdMet>5__3 = false;
					if (dealerConfig.SafetyEnabled && currentDealerActivity <= dealerConfig.SafetyThreshold)
					{
						<safetyThresholdMet>5__3 = true;
						<>7__wrap3 = allCartelDealers;
						<>7__wrap4 = 0;
						goto IL_03cf;
					}
					goto IL_03e9;
					IL_03cf:
					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_03e9;
					IL_0524:
					if (CartelEnforcer.registered)
					{
						<>2__current = CartelEnforcer.Wait60;
						<>1__state = 2;
						return true;
					}
					<>2__current = null;
					<>1__state = 7;
					return true;
					IL_02f7:
					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_030e;
					IL_04b0:
					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_03e9:
					if (!<safetyThresholdMet>5__3)
					{
						if (!<isHostile>5__2)
						{
							<>7__wrap3 = allCartelDealers;
							<>7__wrap4 = 0;
							goto IL_04b0;
						}
						if (NetworkSingleton<TimeManager>.Instance.CurrentTime >= currentStayInsideEnd || NetworkSingleton<TimeManager>.Instance.CurrentTime <= currentStayInsideStart)
						{
							CartelEnforcer.coros.Add(MelonCoroutines.Start(StartActiveSignal()));
						}
					}
					goto IL_0524;
				}
			}

			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>, IDisposable, IEnumerator
		{
			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_0260: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_026d: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0330: Unknown result type (might be due to invalid IL or missing references)
				//IL_034c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0351: Unknown result type (might be due to invalid IL or missing references)
				//IL_0354: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b9: 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_039f;
				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;
					foreach (ItemSlot allSlot in ((Dealer)dealEvent.dealer).GetAllSlots())
					{
						if (allSlot.ItemInstance == null)
						{
							continue;
						}
						ItemInstance itemInstance = allSlot.ItemInstance;
						ProductItemInstance val2 = (ProductItemInstance)(object)((itemInstance is ProductItemInstance) ? itemInstance : null);
						if (val2 != null)
						{
							if (((QualityItemInstance)val2).Quality < correspondingQuality)
							{
								flag2 = true;
								((QualityItemInstance)val2).Quality = correspondingQuality;
							}
							else
							{
								flag2 = true;
							}
							break;
						}
					}
					if (!flag2)
					{
						ItemInstance defaultInstance = Registry.GetItem("cocaine").GetDefaultInstance(4);
						QualityItemInstance val3 = (QualityItemInstance)(object)((defaultInstance is QualityItemInstance) ? defaultInstance : null);
						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_039f;
				}
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_039f:
					<>2__current = null;
					<>1__state = 3;
					return true;
					IL_005e:
					<>2__current = CartelEnforcer.Wait025;
					<>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 <StartActiveSignal>d__21 : IEnumerator<object>, IDisposable, IEnumerator
		{
			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_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_0617: Unknown result type (might be due to invalid IL or missing references)
				//IL_0621: Expected O, but got Unknown
				bool result;
				try
				{
					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)];
							if (!InterceptEvent.contractGuids.Contains(((Quest)<contract>5__3).GUID.ToString()) && !<validContracts>5__2.ContainsValue(<contract>5__3) && !consumedGUIDs.Contains(((Quest)<contract>5__3).GUID.ToString()) && !playerDealerStolen.ContainsKey(((Quest)<contract>5__3).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 && !playerDealerStolen.ContainsKey(((Quest)<contract>5__3).GUID.ToString()) && !consumedGUIDs.Contains(((Quest)<contract>5__3).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;
											playerDealerStolen.Add(((Quest)<contract>5__3).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>, IDisposable, IEnumerator
		{
			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 = Object.FindObjectsOfType<CartelDealer>(true);
			foreach (CartelDealer val in array)
			{
				NPCEvent_StayInBuilding val2 = null;
				if (((NPC)val).Behaviour.ScheduleManager.ActionList != null)
				{
					foreach (NPCAction action in ((NPC)val).Behaviour.ScheduleManager.ActionList)
					{
						NPCEvent_StayInBuilding val3 = (NPCEvent_StayInBuilding)(object)((action is NPCEvent_StayInBuilding) ? action : null);
						if (val3 != null)
						{
							val2 = val3;
						}
					}
				}
				if ((Object)(object)val2 != (Object)null && !dealerBuildings.ContainsKey(val2.Building))
				{
					dealerBuildings.Add(val2.Building, 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)
			{
				foreach (NPCAction action in ((NPC)dealer).Behaviour.ScheduleManager.ActionList)
				{
					NPCEvent_StayInBuilding val2 = (NPCEvent_StayInBuilding)(object)((action is NPCEvent_StayInBuilding) ? action : null);
					if (val2 != 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)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Expected O, but got Unknown
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Expected O, but got Unknown
			string text = "";
			Object obj = 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", 
			});
			AvatarEquippable component = Object.Instantiate<GameObject>((GameObject)(object)((obj is GameObject) ? obj : null), 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 = (AvatarWeapon)(object)((component is AvatarWeapon) ? component : null);
				if (val3 != 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)
				{
					foreach (NPCAction action in ((NPC)dealer).Behaviour.ScheduleManager.ActionList)
					{
						NPCEvent_StayInBuilding val6 = (NPCEvent_StayInBuilding)(object)((action is NPCEvent_StayInBuilding) ? action : null);
						if (val6 != null)
						{
							val4 = val6;
							continue;
						}
						NPCSignal_HandleDeal val7 = (NPCSignal_HandleDeal)(object)((action is NPCSignal_HandleDeal) ? action : null);
						if (val7 != null)
						{
							val5 = val7;
						}
					}
					if ((Object)(object)val4 != (Object)null)
					{
						((NPCAction)val4).StartTime = defaultStayInsideStart;
						((NPCEvent)val4).EndTime = defaultStayInsideEnd;
						((NPCEvent)val4).Duration = defaultStayInsideDur;
						((NPCAction)val4).onEnded = (Action)Delegate.Combine(((NPCAction)val4).onEnded, new Action(onStayInsideEnd));
					}
					if ((Object)(object)val5 != (Object)null)
					{
						((NPCSignal)val5).MaxDuration = 60;
						((NPCAction)val5).onEnded = (Action)Delegate.Combine(((NPCAction)val5).onEnded, new Action(onDealSignalEnd));
					}
				}
				UnityEvent onDieOrKnockedOut = ((NPC)dealer).Health.onDieOrKnockedOut;
				object obj2 = <>O.<0>__OnDealerDied;
				if (obj2 == null)
				{
					UnityAction val8 = OnDealerDied;
					<>O.<0>__OnDealerDied = val8;
					obj2 = (object)val8;
				}
				onDieOrKnockedOut.AddListener((UnityAction)obj2);
				((NPC)dealer).Health.onDieOrKnockedOut.AddListener(new UnityAction(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 val10 = 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);
							val10 = ((Component)dealer).transform.position + onUnitSphere * num4;
							num3++;
						}
						while (closestPlayer.IsPointVisibleToPlayer(val10, 30f, 5f));
						if (!(val10 == Vector3.zero))
						{
							List<CartelGoon> list2 = NetworkSingleton<Cartel>.Instance.GoonPool.SpawnMultipleGoons(val10, 2, true);
							foreach (CartelGoon item in list2)
							{
								((NPC)item).Movement.WarpToNavMesh();
								if (Random.Range(0f, 1f) > 0.7f && AmbushOverrides.RangedWeapons != null && AmbushOverrides.RangedWeapons.Length != 0)
								{
									((NPC)item).Behaviour.CombatBehaviour.DefaultWeapon = AmbushOverrides.RangedWeapons[Random.Range(0, AmbushOverrides.RangedWeapons.Length)];
								}
								else if (AmbushOverrides.MeleeWeapons != null && AmbushOverrides.MeleeWeapons.Length != 0)
								{
									((NPC)item).Behaviour.CombatBehaviour.DefaultWeapon = AmbushOverrides.MeleeWeapons[Random.Range(0, AmbushOverrides.MeleeWeapons.Length)];
								}
								item.AttackEntity(((Component)closestPlayer).GetComponent<ICombatTargetable>(), true);
							}
							CartelEnforcer.coros.Add(MelonCoroutines.Start(DespawnDefenderGoonsSoon(list2)));
						}
					}
				}
				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 val9 in array)
			{
				if ((Object)(object)((NPC)val9).Avatar.CurrentSettings == (Object)null)
				{
					list.Add(val9);
				}
			}
			if (list.Count > 0)
			{
				foreach (CartelDealer item2 in list)
				{
					item2.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_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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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)
			if (!IsWalkingEnabled(d))
			{
				return;
			}
			if (Random.Range(0f, 1f) > 0.5f)
			{
				DeliveryLocation randomUnscheduledDeliveryLocation = Singleton<Map>.instance.Regions[((NPC)d).Region].GetRandomUnscheduledDeliveryLocation();
				((NPC)d).Movement.SetDestination(randomUnscheduledDeliveryLocation.CustomerStandPoint.position);
			}
			else
			{
				List<DeadDrop> list = DeadDrop.DeadDrops.FindAll((DeadDrop drop) => drop.Region == ((NPC)d).Region);
				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>, IDisposable, IEnumerator
		{
			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>, IDisposable, IEnumerator
		{
			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_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: 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;
					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[] regionalActivities = NetworkSingleton<Cartel>.Instance.Activities.RegionalActivities;
					for (int i = 0; i < regionalActivities.Length; i++)
					{
						<>c__DisplayClass3_1 CS$<>8__locals1 = new <>c__DisplayClass3_1
						{
							act = regionalActivities[i]
						};
						actFreqMapping.Add(new HrPassParameterMap
						{
							itemDesc = "Cartel Regional Activities (" + ((object)(EMapRegion)(ref CS$<>8__locals1.act.Region)).ToString() + ")",
							Getter = () => CS$<>8__locals1.act.HoursUntilNextActivity,
							Setter = delegate(int value)
							{
								CS$<>8__locals1.act.HoursUntilNextActivity = value;
							},
							HourPassAction = delegate
							{
								CS$<>8__locals1.act.HourPass();
							},
							modTicksPassed = 0,
							currentModHours = CS$<>8__locals1.act.HoursUntilNextActivity,
							CanPassHour = () => (int)NetworkSingleton<Cartel>.Instance.Status == 2
						});
						num++;
						foreach (CartelActivity activity in CS$<>8__locals1.act.Activities)
						{
							CartelRegActivityHours cartelRegActivityHours = new CartelRegActivityHours
							{
								region = (int)CS$<>8__locals1.act.Region
							};
							int num2 = 0;
							<>c__DisplayClass3_2 CS$<>8__locals0;
							if (activity is StealDeadDrop)
							{
								cartelRegActivityHours.cartelActivityClass = 0;
								num2 = GetActivityHours(CartelEnforcer.currentConfig.deadDropStealFrequency);
							}
							else
							{
								CS$<>8__locals0 = new <>c__DisplayClass3_2
								{
									cartelCustomerDeal = (CartelCustomerDeal)(object)((activity is CartelCustomerDeal) ? activity : null)
								};
								if (CS$<>8__locals0.cartelCustomerDeal != null)
								{
									cartelRegActivityHours.cartelActivityClass = 1;
									num2 = GetActivityHours(CartelEnforcer.currentConfig.cartelCustomerDealFrequency);
									if (CartelEnforcer.currentConfig.enhancedDealers)
									{
										((CartelActivity)CS$<>8__locals0.cartelCustomerDeal).onActivated = (Action)Delegate.Combine(((CartelActivity)CS$<>8__locals0.cartelCustomerDeal).onActivated, new Action(OnCustomerDealActive));
									}
								}
								else
								{
									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;
					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++;
					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>, IDisposable, IEnumerator
		{
			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
	{
		[HarmonyPrefix]
		public static bool Prefix(CartelActivities __instance)
		{
			//IL_006d: 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_0084: 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_00dc: 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)
			//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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			__instance.HoursUntilNextGlobalActivity = CartelActivities.GetNewCooldown();
			if (!__instance.CanNewActivityBegin())
			{
				return false;
			}
			List<CartelActivity> activitiesReadyToStart = NetworkSingleton<Cartel>.Instance.Activities.GetActivitiesReadyToStart();
			List<EMapRegion> validRegionsForActivity = NetworkSingleton<Cartel>.Instance.Activities.GetValidRegionsForActivity();
			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);
			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_0175: 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);
				}
			}
			foreach (CartelActivity activity in __instance.Activities)
			{
				int num = 0;
				num = ((!(activity is StealDeadDrop)) ? ((activity is CartelCustomerDeal) ? 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(activity))
					{
						List<int> value = new List<int>
						{
							list[j],
							num
						};
						enabledActivities.Add(activity, 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>, IDisposable, IEnumerator
		{
			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)
					{
						foreach (CartelActivity globalActivity in NetworkSingleton<Cartel>.Instance.Activities.GlobalActivities)
						{
							float num = 0f;
							num = ((!(CartelEnforcer.currentConfig.activityInfluenceMin > 0f) || !(globalActivity.InfluenceRequirement > 0f)) ? Mathf.Lerp(globalActivity.InfluenceRequirement, 0f, 0f - CartelEnforcer.currentConfig.activityInfluenceMin) : Mathf.Lerp(globalActivity.InfluenceRequirement, 1f, CartelEnforcer.currentConfig.activityInfluenceMin));
							globalActivity.InfluenceRequirement = num;
						}
						CartelRegionActivities[] array = Object.FindObjectsOfType<CartelRegionActivities>(true);
						for (int i = 0; i < array.Length; i++)
						{
							foreach (CartelActivity activity in array[i].Activities)
							{
								float num2 = 0f;
								num2 = ((!(CartelEnforcer.currentConfig.activityInfluenceMin > 0f) || !(activity.InfluenceRequirement > 0f)) ? Mathf.Lerp(activity.InfluenceRequirement, 0f, 0f - CartelEnforcer.currentConfig.activityInfluenceMin) : Mathf.Lerp(activity.InfluenceRequirement, 1f, CartelEnforcer.currentConfig.activityInfluenceMin));
								activity.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>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private MapRegionData[] <>7__wrap1;

			private int <>7__wrap2;

			private MapRegionData <region>5__4;

			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()
			{
				<>7__wrap1 = null;
				<region>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>7__wrap1 = Singleton<Map>.Instance.Regions;
					<>7__wrap2 = 0;
					goto IL_00ba;
				case 1:
					<>1__state = -1;
					if (ShouldChangeInfluence(<region>5__4.Region))
					{
						NetworkSingleton<Cartel>.Instance.Influence.ChangeInfluence(<region>5__4.Region, -0.02f + CartelEnforcer.influenceConfig.passiveInfluenceGainPerDay);
					}
					<region>5__4 = null;
					<>7__wrap2++;
					goto IL_00ba;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_00ba:
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						<region>5__4 = <>7__wrap1[<>7__wrap2];
						<>2__current = CartelEnforcer.Wait05;
						<>1__state = 1;
						return true;
					}
					<>7__wrap1 = 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();
			}
		}

		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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			if ((int)NetworkSingleton<Cartel>.Instance.Status != 2)
			{
				result = false;
			}
			if (InstanceFinder.IsServer && Singleton<Map>.Instance.GetUnlockedRegions().Contains(region))
			{
				result = true;
			}
			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>, IDisposable, IEnumerator
		{
			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_037c: 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_0111;
					case 1:
						<>1__state = -1;
						<preElapsed>5__3 += 0.25f;
						if (NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons.Count != currentlySpawned.Count)
						{
							foreach (CartelGoon spawnedGoon in NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons)
							{
								if (!currentlySpawned.Contains(spawnedGoon) && !<ambushSpawned>5__4.Contains(spawnedGoon) && !CartelGathering.spawnedGatherGoons.Contains(spawnedGoon))
								{
									<ambushSpawned>5__4.Add(spawnedGoon);
								}
							}
						}
						goto IL_0111;
					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_024b;
					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_02f8;
						}
						IL_024b:
						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_02f8;
						IL_0111:
						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 = 360f;
						<elapsed>5__6 = 0f;
						<deadGoons>5__7 = new List<CartelGoon>();
						<spawnedCount>5__8 = <ambushSpawned>5__4.Count;
						goto IL_0317;
						IL_02f8:
						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_0317;
						IL_0317:
						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_024b;
					}
					if ((<ambushSpawned>5__4.Count == 0 || <deadGoons>5__7.Count == <spawnedCount>5__8) && InstanceFinder.IsServer)
					{
						float num = 0.1f + 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_001d: Unknown result type (might be due to invalid IL or missing references)
			List<CartelGoon> currentlySpawned = NetworkSingleton<Cartel>.Instance.GoonPool.spawnedGoons.ToList();
			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_0044: 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 = 0.075f + 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>, IDisposable, IEnumerator
		{
			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_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Expected O, but got Unknown
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				//IL_016a: 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_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Expected O, but got Unknown
				//IL_01aa: 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 (!CartelEnforcer.registered)
					{
						return false;
					}
					CartelRegionActivities[] regionalActivities = NetworkSingleton<Cartel>.Instance.Activities.RegionalActivities;
					int num = 1;
					if (ambushConfig.addedAmbushes != null && ambushConfig.addedAmbushes.Count > 0)
					{
						using List<NewAmbushConfig>.Enumerator enumerator = ambushConfig.addedAmbushes.GetEnumerator();
						while (enumerator.MoveNext())
						{
							<>c__DisplayClass6_0 CS$<>8__locals0 = new <>c__DisplayClass6_0
							{
								config = enumerator.Current
							};
							CartelRegionActivities val = ((IEnumerable<CartelRegionActivities>)regionalActivities).FirstOrDefault((Func<CartelRegionActivities, bool>)((CartelRegionActivities act) => (int)act.Region == CS$<>8__locals0.config.mapRegion));
							Transform val2 = ((Component)val).transform.Find("Ambush locations");
							GameObject val3 = new GameObject($"AmbushLocation ({val2.childCount})");
							CartelAmbushLocation val4 = val3.AddComponent<CartelAmbushLocation>();
							val3.transform.position = CS$<>8__locals0.config.ambushPosition;
							val4.DetectionRadius = CS$<>8__locals0.config.detectionRadius;
							GameObject val5 = new GameObject("SpawnPoints");
							val5.transform.parent = val3.transform;
							val4.AmbushPoints = (Transform[])(object)new Transform[CS$<>8__locals0.config.spawnPoints.Count];
							int num2 = 0;
							foreach (Vector3 spawnPoint in CS$<>8__locals0.config.spawnPoints)
							{
								GameObject val6 = new GameObject("SP" + ((num2 == 0) ? "" : (" (" + num2 + ")")));
								val6.transform.position = spawnPoint;
								val6.transform.parent = val5.transform;
								val4.AmbushPoints[num2] = val6.transform;
								((Behaviour)val4).enabled = true;
								num2++;
							}
							num++;
							CartelAmbushLocation[] ambushLocations = val.AmbushLocations;
							CartelAmbushLocation[] array = (CartelAmbushLocation[])(object)new CartelAmbushLocation[ambushLocations.Length + 1];
							Array.Copy(ambushLocations, array, ambushLocations.Length);
							array[^1] = val4;
							val.AmbushLocations = array;
							val3.transform.parent = val2;
						}
					}
					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 <ApplyGameDefaultAmbush>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			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 <ApplyGameDefaultAmbush>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: 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.Wait5;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!CartelEnforcer.registered)
					{
						return false;
					}
					ambushConfig = ConfigLoader.LoadAmbushConfig();
					gameDefaultAmbush = ConfigLoader.LoadDefaultAmbushConfig();
					ambushSettings = ConfigLoader.LoadAmbushSettings();
					CartelRegionActivities[] array = Object.FindObjectsOfType<CartelRegionActivities>(true);
					int num = 0;
					CartelRegionActivities[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						CartelAmbushLocation[] ambushLocations = array2[i].AmbushLocations;
						foreach (CartelAmbushLocation val in ambushLocations)
						{
							List<Vector3> list = val.AmbushPoints.Select((Transform tr) => tr.position).ToList();
							NewAmbushConfig newAmbushConfig = gameDefaultAmbush.addedAmbushes.ElementAt(num);
							num++;
							if (newAmbushConfig.spawnPoints.Count != list.Count)
							{
								continue;
							}
							if (((Component)val).transform.position != newAmbushConfig.ambushPosition)
							{
								((Component)val).transform.position = newAmbushConfig.ambushPosition;
							}
							if (val.DetectionRadius != newAmbushConfig.detectionRadius)
							{
								val.DetectionRadius = newAmbushConfig.detectionRadius;
							}
							for (int k = 0; k < newAmbushConfig.spawnPoints.Count; k++)
							{
								if (newAmbushConfig.spawnPoints[k] != list[k])
								{
									val.AmbushPoints[k].position = newAmbushConfig.spawnPoints[k];
								}
							}
						}
					}
					<>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 <SetAmbushGeneralSettings>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			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 <SetAmbushGeneralSettings>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown resu