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 FishNet.Connection;
using FishNet.Managing;
using FishNet.Managing.Object;
using FishNet.Object;
using HarmonyLib;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using NACopsV1;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using ScheduleOne;
using ScheduleOne.AvatarFramework;
using ScheduleOne.AvatarFramework.Equipping;
using ScheduleOne.Building.Doors;
using ScheduleOne.Combat;
using ScheduleOne.Core.Items.Framework;
using ScheduleOne.DevUtilities;
using ScheduleOne.Doors;
using ScheduleOne.Economy;
using ScheduleOne.Employees;
using ScheduleOne.EntityFramework;
using ScheduleOne.GameTime;
using ScheduleOne.ItemFramework;
using ScheduleOne.Law;
using ScheduleOne.Management;
using ScheduleOne.Map;
using ScheduleOne.Money;
using ScheduleOne.NPCs;
using ScheduleOne.NPCs.Behaviour;
using ScheduleOne.ObjectScripts;
using ScheduleOne.Persistence;
using ScheduleOne.PlayerScripts;
using ScheduleOne.Police;
using ScheduleOne.Product;
using ScheduleOne.Property;
using ScheduleOne.Quests;
using ScheduleOne.Storage;
using ScheduleOne.UI;
using ScheduleOne.UI.Handover;
using ScheduleOne.UI.MainMenu;
using ScheduleOne.Vision;
using ScheduleOne.VoiceOver;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(NACops), "NACopsV1", "2.0.2", "XOWithSauce", null)]
[assembly: MelonColor]
[assembly: MelonOptionalDependencies(new string[] { "FishNet.Runtime" })]
[assembly: MelonGame("TVGS", "Schedule I")]
[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 2026 Source MIT")]
[assembly: AssemblyDescription("Schedule I NACops Mod")]
[assembly: AssemblyFileVersion("2.0.2.0")]
[assembly: AssemblyInformationalVersion("2.0.2")]
[assembly: AssemblyProduct("NACops")]
[assembly: AssemblyTitle("NACopsV1")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/XOWithSauce/schedule-nacops")]
[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 NACopsV1
{
	public class FootPatrolGenerator
	{
		public static Dictionary<PatrolInstance, List<string>> generatedPatrolInstances = new Dictionary<PatrolInstance, List<string>>();

		public static ConfigLoader.FootPatrolsSerialized serPatrols;

		public static PatrolInstance[] GeneratePatrol(LawActivitySettings template, string day = "")
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (generatedPatrolInstances.Count == 0)
			{
				DebugModule.Log("Generating new patrol routes", "GeneratePatrol");
				Transform parent = ((Component)Singleton<LawController>.Instance).transform.Find("PatrolRoutes");
				if (serPatrols == null)
				{
					serPatrols = ConfigLoader.LoadPatrolsConfig();
				}
				foreach (SerializedFootPatrol loadedPatrol in serPatrols.loadedPatrols)
				{
					GameObject val = new GameObject(loadedPatrol.name);
					DebugModule.Log("Generate object for patrol: " + loadedPatrol.name, "GeneratePatrol");
					DebugModule.Log("- Days: " + string.Join(" ", loadedPatrol.days), "GeneratePatrol");
					FootPatrolRoute val2 = val.AddComponent<FootPatrolRoute>();
					((Object)val2).name = loadedPatrol.name;
					val2.StartWaypointIndex = 0;
					Transform[] array = (Transform[])(object)new Transform[loadedPatrol.waypoints.Count];
					for (int i = 0; i < loadedPatrol.waypoints.Count; i++)
					{
						GameObject val3 = new GameObject((i == 0) ? "Waypoint" : $"Waypoint ({i})");
						val3.transform.position = loadedPatrol.waypoints[i];
						val3.transform.parent = val.transform;
						array[i] = val3.transform;
					}
					val2.Waypoints = array;
					val.transform.parent = parent;
					PatrolInstance val4 = new PatrolInstance();
					val4.StartTime = loadedPatrol.startTime;
					val4.EndTime = loadedPatrol.endTime;
					val4.Members = loadedPatrol.members;
					val4.Route = val2;
					val4.OnlyIfCurfewEnabled = loadedPatrol.onlyIfCurfew;
					val4.IntensityRequirement = loadedPatrol.intensityRequirement;
					val.transform.parent = parent;
					val.SetActive(true);
					generatedPatrolInstances.Add(val4, loadedPatrol.days);
				}
			}
			if (day == "")
			{
				int num = template.Patrols.Length;
				int count = generatedPatrolInstances.Count;
				int num2 = num + count;
				PatrolInstance[] array2 = (PatrolInstance[])(object)new PatrolInstance[num2];
				Array.Copy(template.Patrols, array2, num);
				int num3 = num;
				foreach (KeyValuePair<PatrolInstance, List<string>> generatedPatrolInstance in generatedPatrolInstances)
				{
					if (num3 >= num2)
					{
						break;
					}
					array2[num3] = generatedPatrolInstance.Key;
					num3++;
				}
				return array2;
			}
			int num4 = template.Patrols.Length;
			int num5 = 0;
			foreach (KeyValuePair<PatrolInstance, List<string>> generatedPatrolInstance2 in generatedPatrolInstances)
			{
				if (generatedPatrolInstance2.Value.Contains(day))
				{
					num5++;
				}
			}
			if (num5 == 0)
			{
				return template.Patrols;
			}
			int num6 = num4 + num5;
			PatrolInstance[] array3 = (PatrolInstance[])(object)new PatrolInstance[num6];
			Array.Copy(template.Patrols, array3, num4);
			int num7 = num4;
			foreach (KeyValuePair<PatrolInstance, List<string>> generatedPatrolInstance3 in generatedPatrolInstances)
			{
				if (num7 >= num6)
				{
					break;
				}
				if (generatedPatrolInstance3.Value.Contains(day))
				{
					array3[num7] = generatedPatrolInstance3.Key;
					num7++;
				}
			}
			DebugModule.Log($"    {day}: Added {num5} patrols ({num4} -> {num6})", "GeneratePatrol");
			return array3;
		}
	}
	[Serializable]
	public class SerializedFootPatrol
	{
		public int startTime = 1900;

		public int endTime = 500;

		public int members = 1;

		public int intensityRequirement = 1;

		public bool onlyIfCurfew;

		public string name = "NACops Extra Loop";

		public List<string> days;

		public List<Vector3> waypoints = new List<Vector3>();
	}
	public class SentryGenerator
	{
		public static Dictionary<SentryInstance, List<string>> generatedSentryInstances = new Dictionary<SentryInstance, List<string>>();

		public static ConfigLoader.SentrysSerialized serSentries;

		public static SentryInstance[] GenerateSentry(LawActivitySettings template, string day = "")
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			if (generatedSentryInstances.Count == 0)
			{
				DebugModule.Log("Generating new sentry spots", "GenerateSentry");
				Transform val = ((Component)Singleton<LawController>.Instance).transform.Find("Sentry Locations");
				if ((Object)(object)val == (Object)null)
				{
					DebugModule.Log("    Sentry Locations transform is null", "GenerateSentry");
				}
				DebugModule.Log("    Load Sentry Config", "GenerateSentry");
				if (serSentries == null)
				{
					serSentries = ConfigLoader.LoadSentryConfig();
				}
				DebugModule.Log("    Loaded Patrols config count: " + serSentries.loadedSentrys.Count, "GenerateSentry");
				foreach (SerializedSentry loadedSentry in serSentries.loadedSentrys)
				{
					GameObject val2 = new GameObject(loadedSentry.name);
					DebugModule.Log("Generate object for patrol: " + loadedSentry.name, "GenerateSentry");
					DebugModule.Log("- Days: " + string.Join(" ", loadedSentry.days), "GenerateSentry");
					SentryLocation val3 = val2.AddComponent<SentryLocation>();
					val3.Routes = new List<SentryRoute>();
					SentryRoute val4 = new SentryRoute();
					GameObject val5 = new GameObject("Stand point");
					val5.transform.parent = val2.transform;
					val5.transform.SetPositionAndRotation(loadedSentry.standPosition1, Quaternion.Euler(loadedSentry.pos1Rotation));
					GameObject val6 = new GameObject("Stand point (1)");
					val6.transform.parent = val2.transform;
					val6.transform.SetPositionAndRotation(loadedSentry.standPosition2, Quaternion.Euler(loadedSentry.pos2Rotation));
					val4.RoutePoints = (Transform[])(object)new Transform[2] { val5.transform, val6.transform };
					val4.MinutesPerPoint = 60;
					val3.Routes.Add(val4);
					((Component)val3).gameObject.SetActive(true);
					SentryInstance val7 = new SentryInstance();
					val7.StartTime = loadedSentry.startTime;
					val7.EndTime = loadedSentry.endTime;
					val7.Members = loadedSentry.members;
					val7._potentialLocations = (SentryLocation[])(object)new SentryLocation[1] { val3 };
					val7.OnlyIfCurfewEnabled = loadedSentry.onlyIfCurfew;
					val7.IntensityRequirement = loadedSentry.intensityRequirement;
					val2.transform.parent = val;
					val2.SetActive(true);
					generatedSentryInstances.Add(val7, loadedSentry.days);
				}
			}
			if (day == "")
			{
				int num = template.Sentries.Length;
				int count = generatedSentryInstances.Count;
				int num2 = num + count;
				SentryInstance[] array = (SentryInstance[])(object)new SentryInstance[num2];
				Array.Copy(template.Sentries, array, num);
				int num3 = num;
				foreach (KeyValuePair<SentryInstance, List<string>> generatedSentryInstance in generatedSentryInstances)
				{
					if (num3 >= num2)
					{
						break;
					}
					array[num3] = generatedSentryInstance.Key;
					num3++;
				}
				return array;
			}
			int num4 = template.Sentries.Length;
			int num5 = 0;
			foreach (KeyValuePair<SentryInstance, List<string>> generatedSentryInstance2 in generatedSentryInstances)
			{
				if (generatedSentryInstance2.Value.Contains(day))
				{
					num5++;
				}
			}
			if (num5 == 0)
			{
				return template.Sentries;
			}
			int num6 = num4 + num5;
			SentryInstance[] array2 = (SentryInstance[])(object)new SentryInstance[num6];
			Array.Copy(template.Sentries, array2, num4);
			int num7 = num4;
			foreach (KeyValuePair<SentryInstance, List<string>> generatedSentryInstance3 in generatedSentryInstances)
			{
				if (num7 >= num6)
				{
					break;
				}
				if (generatedSentryInstance3.Value.Contains(day))
				{
					array2[num7] = generatedSentryInstance3.Key;
					num7++;
				}
			}
			DebugModule.Log($"    {day}: Added {num5} sentries ({num4} -> {num6})", "GenerateSentry");
			return array2;
		}
	}
	[Serializable]
	public class SerializedSentry
	{
		public int startTime = 1900;

		public int endTime = 500;

		public int members = 1;

		public int intensityRequirement = 1;

		public bool onlyIfCurfew;

		public string name;

		public List<string> days;

		public Vector3 standPosition1;

		public Vector3 pos1Rotation;

		public Vector3 standPosition2;

		public Vector3 pos2Rotation;
	}
	public class VehiclePatrolGenerator
	{
		public static Dictionary<VehiclePatrolInstance, List<string>> generatedVehiclePatrolInstances = new Dictionary<VehiclePatrolInstance, List<string>>();

		public static ConfigLoader.VehiclePatrolsSerialized serVehiclePatrols;

		public static VehiclePatrolInstance[] GenerateVehiclePatrol(LawActivitySettings template, string day = "")
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (generatedVehiclePatrolInstances.Count == 0)
			{
				DebugModule.Log("Generating new vehicle patrol routes", "GenerateVehiclePatrol");
				Transform parent = ((Component)Singleton<LawController>.Instance).transform.Find("VehiclePatrolRoutes");
				if (serVehiclePatrols == null)
				{
					serVehiclePatrols = ConfigLoader.LoadVehiclePatrolsConfig();
				}
				foreach (SerializedVehiclePatrol loadedVehiclePatrol in serVehiclePatrols.loadedVehiclePatrols)
				{
					GameObject val = new GameObject(loadedVehiclePatrol.name);
					DebugModule.Log("Generate object for patrol: " + loadedVehiclePatrol.name, "GenerateVehiclePatrol");
					DebugModule.Log("- Days: " + string.Join(" ", loadedVehiclePatrol.days), "GenerateVehiclePatrol");
					VehiclePatrolRoute val2 = val.AddComponent<VehiclePatrolRoute>();
					((Object)val2).name = loadedVehiclePatrol.name;
					val2.StartWaypointIndex = 0;
					Transform[] array = (Transform[])(object)new Transform[loadedVehiclePatrol.waypoints.Count];
					for (int i = 0; i < loadedVehiclePatrol.waypoints.Count; i++)
					{
						GameObject val3 = new GameObject((i == 0) ? "Waypoint" : $"Waypoint ({i})");
						val3.transform.position = loadedVehiclePatrol.waypoints[i];
						val3.transform.parent = val.transform;
						array[i] = val3.transform;
					}
					val2.Waypoints = array;
					val.transform.parent = parent;
					VehiclePatrolInstance val4 = new VehiclePatrolInstance();
					val4.StartTime = loadedVehiclePatrol.startTime;
					val4.Route = val2;
					val4.IntensityRequirement = loadedVehiclePatrol.intensityRequirement;
					val4.OnlyIfCurfewEnabled = loadedVehiclePatrol.onlyIfCurfew;
					val.transform.parent = parent;
					val.SetActive(true);
					generatedVehiclePatrolInstances.Add(val4, loadedVehiclePatrol.days);
				}
			}
			if (day == "")
			{
				int num = template.VehiclePatrols.Length;
				int count = generatedVehiclePatrolInstances.Count;
				int num2 = num + count;
				VehiclePatrolInstance[] array2 = (VehiclePatrolInstance[])(object)new VehiclePatrolInstance[num2];
				Array.Copy(template.VehiclePatrols, array2, num);
				int num3 = num;
				foreach (KeyValuePair<VehiclePatrolInstance, List<string>> generatedVehiclePatrolInstance in generatedVehiclePatrolInstances)
				{
					if (num3 >= num2)
					{
						break;
					}
					array2[num3] = generatedVehiclePatrolInstance.Key;
					num3++;
				}
				return array2;
			}
			int num4 = template.VehiclePatrols.Length;
			int num5 = 0;
			foreach (KeyValuePair<VehiclePatrolInstance, List<string>> generatedVehiclePatrolInstance2 in generatedVehiclePatrolInstances)
			{
				if (generatedVehiclePatrolInstance2.Value.Contains(day))
				{
					num5++;
				}
			}
			if (num5 == 0)
			{
				return template.VehiclePatrols;
			}
			int num6 = num4 + num5;
			VehiclePatrolInstance[] array3 = (VehiclePatrolInstance[])(object)new VehiclePatrolInstance[num6];
			Array.Copy(template.VehiclePatrols, array3, num4);
			int num7 = num4;
			foreach (KeyValuePair<VehiclePatrolInstance, List<string>> generatedVehiclePatrolInstance3 in generatedVehiclePatrolInstances)
			{
				if (num7 >= num6)
				{
					break;
				}
				if (generatedVehiclePatrolInstance3.Value.Contains(day))
				{
					array3[num7] = generatedVehiclePatrolInstance3.Key;
					num7++;
				}
			}
			DebugModule.Log($"    {day}: Added {num5} vehicle patrols ({num4} -> {num6})", "GenerateVehiclePatrol");
			return array3;
		}
	}
	[Serializable]
	public class SerializedVehiclePatrol
	{
		public int startTime = 2300;

		public int intensityRequirement = 1;

		public bool onlyIfCurfew;

		public string name = "NACops Vehicle Extra Loop";

		public List<string> days;

		public List<Vector3> waypoints = new List<Vector3>();
	}
	[HarmonyPatch(typeof(Customer), "ProcessHandover")]
	public static class Customer_ProcessHandover_Patch
	{
		[CompilerGenerated]
		private sealed class <DisposeSummoned>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

			public bool instant;

			public Player target;

			private int <lifeTime>5__2;

			private int <maxTime>5__3;

			private NPC <npc>5__4;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = NACops.Wait1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					<lifeTime>5__2 = 0;
					<maxTime>5__3 = 20;
					<npc>5__4 = ((Component)((NetworkBehaviour)offc).NetworkObject).GetComponent<NPC>();
					if (instant || !((Object)(object)target != (Object)null) || !((Object)(object)<npc>5__4 != (Object)null))
					{
						break;
					}
					goto IL_00cb;
				case 2:
					{
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						goto IL_00cb;
					}
					IL_00cb:
					if (<lifeTime>5__2 <= <maxTime>5__3 || target.IsArrested || <npc>5__4.Health.IsDead || <npc>5__4.Health.IsKnockedOut)
					{
						<lifeTime>5__2++;
						<>2__current = NACops.Wait1;
						<>1__state = 2;
						return true;
					}
					break;
				}
				try
				{
					if (NACops.currentSummoned.Contains(offc))
					{
						NACops.currentSummoned.Remove(offc);
					}
					if ((Object)(object)<npc>5__4 != (Object)null && NPCManager.NPCRegistry.Contains(<npc>5__4))
					{
						NPCManager.NPCRegistry.Remove(<npc>5__4);
					}
					if ((Object)(object)<npc>5__4 != (Object)null && (Object)(object)((Component)<npc>5__4).gameObject != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)<npc>5__4).gameObject);
					}
				}
				catch (Exception ex)
				{
					MelonLogger.Error((object)ex);
				}
				DebugModule.Log("Disposed summoned bustcop", "DisposeSummoned");
				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 <LateEnableArrest>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

			private float <maxWait>5__2;

			private float <current>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (offc.PursuitBehaviour.arrestingEnabled)
					{
						offc.PursuitBehaviour.arrestingEnabled = false;
					}
					<current>5__3 += 0.1f;
				}
				else
				{
					<>1__state = -1;
					<maxWait>5__2 = 8f;
					<current>5__3 = 0f;
				}
				if (!NACops.registered)
				{
					return false;
				}
				if (!(<current>5__3 >= <maxWait>5__2))
				{
					<>2__current = NACops.Wait01;
					<>1__state = 1;
					return true;
				}
				offc.PursuitBehaviour.arrestingEnabled = true;
				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 <PreProcessHandover>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public bool handoverByPlayer;

			public Customer __instance;

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

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

			[DebuggerHidden]
			public <PreProcessHandover>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;
					if (!handoverByPlayer)
					{
						return false;
					}
					if (NACops.currentConfig.BuyBusts)
					{
						NACops.coros.Add(MelonCoroutines.Start(SummonBustCop(__instance)));
					}
					<>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 <SetTaser>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

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

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

			[DebuggerHidden]
			public <SetTaser>d__4(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;
					((NPC)offc).Behaviour.CombatBehaviour.SetWeapon(((Object)(object)offc.TaserPrefab != (Object)null) ? offc.TaserPrefab.AssetPath : string.Empty);
					if ((Object)(object)((NPC)offc).Behaviour.CombatBehaviour.currentWeapon == (Object)null)
					{
						return false;
					}
					AvatarWeapon currentWeapon = ((NPC)offc).Behaviour.CombatBehaviour.currentWeapon;
					AvatarRangedWeapon val = (AvatarRangedWeapon)(object)((currentWeapon is AvatarRangedWeapon) ? currentWeapon : null);
					if ((Object)(object)val != (Object)null)
					{
						val.CanShootWhileMoving = true;
						val.MagazineSize = 20;
						val.MaxFireRate = 0.3f;
						((AvatarWeapon)val).MaxUseRange = 24f;
						val.ReloadTime = 0.2f;
						val.RaiseTime = 0.1f;
						val.HitChance_MaxRange = 0.6f;
						val.HitChance_MinRange = 0.9f;
						((AvatarWeapon)val).CooldownDuration = 0.3f;
					}
					<>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 <SummonBustCop>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Customer customer;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Expected O, but got Unknown
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				int value = Mathf.RoundToInt(customer.NPC.RelationData.RelationDelta * 10f);
				var (num, num2) = ThresholdUtils.Evaluate(NACops.thresholdConfig.BuyBustProbability, value);
				if (!NACops.currentConfig.DebugMode && Random.Range(num, num2) < 0.5f)
				{
					return false;
				}
				PoliceOfficer val = OfficerOverrides.SpawnOfficerRuntime(autoDeactivate: false);
				((NPC)val).Movement.PauseMovement();
				AvatarUtility.SetRandomAvatar(val);
				((NPC)val).Behaviour.ScheduleManager.DisableSchedule();
				NACops.currentSummoned.Add(val);
				Player val2 = null;
				Vector3 val3 = ((Component)customer).transform.position + ((Component)customer).transform.forward * 3f;
				Vector3 val4 = default(Vector3);
				if (((NPC)val).Movement.GetClosestReachablePoint(val3, ref val4) && val4 != Vector3.zero)
				{
					NACops.coros.Add(MelonCoroutines.Start(SetTaser(val)));
					((NPC)val).Movement.Warp(val4);
					((NPC)val).Movement.ResumeMovement();
					Vector3 centerPoint = ((NPC)val).CenterPoint;
					DebugModule.Log("Drug bust officer spawned now at " + ((object)(Vector3)(ref centerPoint)).ToString(), "SummonBustCop");
					((VOEmitter)val.ChatterVO).Play((EVOLineType)2);
					((NPC)val).Movement.FacePoint(((Component)customer).transform.position, 0.5f);
					float num3 = default(float);
					val2 = Player.GetClosestPlayer(val4, ref num3, (List<Player>)null);
					val2.CrimeData.SetPursuitLevel((EPursuitLevel)3);
					val.BeginFootPursuit(val2.PlayerCode);
					((Behaviour)val.PursuitBehaviour).Enable_Networked();
					NACops.coros.Add(MelonCoroutines.Start(LateEnableArrest(val)));
					val2.CrimeData.AddCrime((Crime)new AttemptingToSell(), 10);
				}
				else
				{
					DebugModule.Log("Failed to Get closest reachable position for drug bust", "SummonBustCop");
					NACops.coros.Add(MelonCoroutines.Start(DisposeSummoned(val, instant: true, val2)));
				}
				NACops.coros.Add(MelonCoroutines.Start(DisposeSummoned(val, instant: false, 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();
			}
		}

		[HarmonyPrefix]
		public static bool Prefix(Customer __instance, EHandoverOutcome outcome, Contract contract, List<ItemInstance> items, bool handoverByPlayer, bool giveBonuses = true)
		{
			NACops.coros.Add(MelonCoroutines.Start(PreProcessHandover(__instance, handoverByPlayer)));
			return true;
		}

		[IteratorStateMachine(typeof(<PreProcessHandover>d__1))]
		public static IEnumerator PreProcessHandover(Customer __instance, bool handoverByPlayer)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PreProcessHandover>d__1(0)
			{
				__instance = __instance,
				handoverByPlayer = handoverByPlayer
			};
		}

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

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

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

		[IteratorStateMachine(typeof(<DisposeSummoned>d__5))]
		public static IEnumerator DisposeSummoned(PoliceOfficer offc, bool instant, Player target)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DisposeSummoned>d__5(0)
			{
				offc = offc,
				instant = instant,
				target = target
			};
		}
	}
	public class UnityContractResolver : DefaultContractResolver
	{
		protected override JsonObjectContract CreateObjectContract(Type objectType)
		{
			JsonObjectContract val = ((DefaultContractResolver)this).CreateObjectContract(objectType);
			if (objectType == typeof(Vector3))
			{
				for (int num = ((Collection<JsonProperty>)(object)val.Properties).Count - 1; num >= 0; num--)
				{
					JsonProperty val2 = ((Collection<JsonProperty>)(object)val.Properties)[num];
					if (val2.PropertyName == "normalized" || val2.PropertyName == "magnitude" || val2.PropertyName == "sqrMagnitude")
					{
						((Collection<JsonProperty>)(object)val.Properties).RemoveAt(num);
					}
				}
			}
			return val;
		}
	}
	public static class ConfigLoader
	{
		[Serializable]
		public class ModConfig
		{
			public bool DebugMode;

			public bool RaidsEnabled = true;

			public bool ExtraOfficerPatrols = true;

			public bool ExtraVehiclePatrols = true;

			public bool ExtraOfficerSentries = true;

			public bool NoOpenCarryWeapons = true;

			public bool PrivateInvestigator = true;

			public bool WeedInvestigator = true;

			public bool CorruptCops = true;

			public bool SnitchingSamples = true;

			public bool BuyBusts = true;

			public bool NearbyCrazyCops = true;

			public bool LethalCops = true;

			public bool RacistCops;
		}

		[Serializable]
		public class NAOfficerConfig
		{
			public int ModAddedVehicleCount = 3;

			public int ModAddedOfficersCount = 8;

			public bool CanEnterBuildings = true;

			public bool OverrideArresting = true;

			public float ArrestTime = 1.25f;

			public float ArrestRange = 3.5f;

			public bool OverrideMovement = true;

			public float MovementSpeedMultiplier = 1.7f;

			public bool OverrideWeapon = true;

			public string WeaponPath = "Avatar/Equippables/M1911";

			public float WeaponDamage = 46f;

			public int WeaponMagSize = 20;

			public float WeaponFireRate = 0.33f;

			public float WeaponMaxRange = 25f;

			public float WeaponReloadTime = 0.5f;

			public float WeaponRaiseTime = 0.2f;

			public float WeaponHitChanceMax = 0.3f;

			public float WeaponHitChanceMin = 0.8f;

			public bool OverrideMaxHealth = true;

			public float OfficerMaxHealth = 175f;

			public bool OverrideBodySearch = true;

			public float BodySearchDuration = 6f;

			public float BodySearchChance = 1f;

			public bool OverrideCombatBeh = true;

			public float CombatGiveUpRange = 40f;

			public float CombatGiveUpTime = 60f;

			public float CombatSearchTime = 60f;

			public float CombatMoveSpeed = 6.8f;

			public int CombatEndAfterHits = 40;
		}

		[Serializable]
		public class RaidConfig
		{
			public float TraverseToPropertySpeed = 0.47f;

			public float ClearPropertySpeed = 0.38f;

			public int MaxDestroyIters = 4;

			public int RaidCopsCount = 3;

			public int DaysUntilCanRaid = 8;

			public int PropertyHeatThreshold = 14;
		}

		[Serializable]
		public class FootPatrolsSerialized
		{
			public List<SerializedFootPatrol> loadedPatrols = new List<SerializedFootPatrol>();
		}

		[Serializable]
		public class VehiclePatrolsSerialized
		{
			public List<SerializedVehiclePatrol> loadedVehiclePatrols = new List<SerializedVehiclePatrol>();
		}

		[Serializable]
		public class SentrysSerialized
		{
			public List<SerializedSentry> loadedSentrys = new List<SerializedSentry>();
		}

		private static string modConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "config.json");

		private static string officerConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "officer.json");

		private static string patrolsConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "Spawn", "patrols.json");

		private static string sentrysConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "Spawn", "sentrys.json");

		private static string vehiclePatrolsConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "Spawn", "vehiclepatrols.json");

		private static string eventFrequencyConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "progression.json");

		private static string raidConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "raid.json");

		private static string propertyHeatConfig = Path.Combine(MelonEnvironment.ModsDirectory, "NACops", "HeatData");

		public static ModConfig LoadModConfig()
		{
			ModConfig modConfig;
			if (File.Exists(ConfigLoader.modConfig))
			{
				try
				{
					modConfig = JsonConvert.DeserializeObject<ModConfig>(File.ReadAllText(ConfigLoader.modConfig));
				}
				catch (Exception ex)
				{
					modConfig = new ModConfig();
					MelonLogger.Warning("Failed to read NACops Mod config: " + ex);
				}
			}
			else
			{
				MelonLogger.Warning("Missing NACops Mod config, creating directory and template.");
				modConfig = new ModConfig();
				Save(modConfig);
			}
			return modConfig;
		}

		public static void Save(ModConfig config)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1);
				Directory.CreateDirectory(Path.GetDirectoryName(modConfig));
				File.WriteAllText(modConfig, contents);
				MelonLogger.Warning("    NACops Mod config, written to: " + modConfig);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Mod config: " + ex);
			}
		}

		public static NAOfficerConfig LoadOfficerConfig()
		{
			NAOfficerConfig nAOfficerConfig;
			if (File.Exists(officerConfig))
			{
				try
				{
					nAOfficerConfig = JsonConvert.DeserializeObject<NAOfficerConfig>(File.ReadAllText(officerConfig));
					nAOfficerConfig.ModAddedOfficersCount = Mathf.Clamp(nAOfficerConfig.ModAddedOfficersCount, 0, 20);
				}
				catch (Exception ex)
				{
					nAOfficerConfig = new NAOfficerConfig();
					MelonLogger.Warning("Failed to read NACops config: " + ex);
				}
			}
			else
			{
				MelonLogger.Warning("Missing NACops Officers config, creating directory and template.");
				nAOfficerConfig = new NAOfficerConfig();
				Save(nAOfficerConfig);
			}
			return nAOfficerConfig;
		}

		public static void Save(NAOfficerConfig config)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)config);
				Directory.CreateDirectory(Path.GetDirectoryName(officerConfig));
				File.WriteAllText(officerConfig, contents);
				MelonLogger.Warning("    NACops Officers config, written to: " + officerConfig);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Officers config: " + ex);
			}
		}

		public static FootPatrolsSerialized LoadPatrolsConfig()
		{
			FootPatrolsSerialized footPatrolsSerialized;
			if (File.Exists(patrolsConfig))
			{
				try
				{
					footPatrolsSerialized = JsonConvert.DeserializeObject<FootPatrolsSerialized>(File.ReadAllText(patrolsConfig));
					List<string> list = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
					foreach (SerializedFootPatrol loadedPatrol in footPatrolsSerialized.loadedPatrols)
					{
						loadedPatrol.members = Mathf.Clamp(loadedPatrol.members, 1, 4);
						loadedPatrol.name = (string.IsNullOrEmpty(loadedPatrol.name) ? "NaCopsPatrol " : loadedPatrol.name);
						loadedPatrol.intensityRequirement = Mathf.Clamp(loadedPatrol.intensityRequirement, 0, 10);
						if (!TimeManager.IsValid24HourTime(loadedPatrol.startTime.ToString()))
						{
							MelonLogger.Warning("FootPatrolsConfig '" + loadedPatrol.name + "' has invalid start time");
							loadedPatrol.startTime = 1900;
						}
						if (!TimeManager.IsValid24HourTime(loadedPatrol.endTime.ToString()))
						{
							MelonLogger.Warning("FootPatrolsConfig '" + loadedPatrol.name + "' has invalid end time");
							loadedPatrol.endTime = 2330;
						}
						if (loadedPatrol.waypoints.Count == 0)
						{
							MelonLogger.Warning("FootPatrolsConfig is missing Waypoints for " + loadedPatrol.name);
						}
						for (int num = loadedPatrol.days.Count - 1; num != -1; num--)
						{
							if (loadedPatrol.days[num] != string.Empty)
							{
								loadedPatrol.days[num] = loadedPatrol.days[num].ToLower();
								if (!list.Contains(loadedPatrol.days[num]))
								{
									MelonLogger.Warning("FootPatrolsConfig '" + loadedPatrol.name + "' has invalid weekday: '" + loadedPatrol.days[num] + "'");
									loadedPatrol.days.RemoveAt(num);
								}
							}
							else
							{
								loadedPatrol.days.RemoveAt(num);
							}
						}
					}
				}
				catch (Exception ex)
				{
					footPatrolsSerialized = new FootPatrolsSerialized();
					MelonLogger.Warning("Failed to read FootPatrolsSerialized config: " + ex);
				}
			}
			else
			{
				footPatrolsSerialized = new FootPatrolsSerialized();
				footPatrolsSerialized.loadedPatrols = new List<SerializedFootPatrol>();
				Save(footPatrolsSerialized);
			}
			return footPatrolsSerialized;
		}

		public static void Save(FootPatrolsSerialized config)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			try
			{
				JsonSerializerSettings val = new JsonSerializerSettings
				{
					ContractResolver = (IContractResolver)(object)new UnityContractResolver()
				};
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1, val);
				Directory.CreateDirectory(Path.GetDirectoryName(patrolsConfig));
				File.WriteAllText(patrolsConfig, contents);
				MelonLogger.Warning("    Foot Patrols Config has been saved!");
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Foot Patrols config: " + ex);
			}
		}

		public static VehiclePatrolsSerialized LoadVehiclePatrolsConfig()
		{
			VehiclePatrolsSerialized vehiclePatrolsSerialized;
			if (File.Exists(vehiclePatrolsConfig))
			{
				try
				{
					vehiclePatrolsSerialized = JsonConvert.DeserializeObject<VehiclePatrolsSerialized>(File.ReadAllText(vehiclePatrolsConfig));
					List<string> list = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
					foreach (SerializedVehiclePatrol loadedVehiclePatrol in vehiclePatrolsSerialized.loadedVehiclePatrols)
					{
						loadedVehiclePatrol.name = (string.IsNullOrEmpty(loadedVehiclePatrol.name) ? "NaCopsVehiclePatrol " : loadedVehiclePatrol.name);
						loadedVehiclePatrol.intensityRequirement = Mathf.Clamp(loadedVehiclePatrol.intensityRequirement, 0, 10);
						if (!TimeManager.IsValid24HourTime(loadedVehiclePatrol.startTime.ToString()))
						{
							MelonLogger.Warning("Vehicle Patrol Config '" + loadedVehiclePatrol.name + "' has invalid start time");
							loadedVehiclePatrol.startTime = 1900;
						}
						if (loadedVehiclePatrol.waypoints.Count == 0)
						{
							MelonLogger.Warning("Vehicle Patrol Config is missing Waypoints for " + loadedVehiclePatrol.name);
						}
						for (int num = loadedVehiclePatrol.days.Count - 1; num != -1; num--)
						{
							if (loadedVehiclePatrol.days[num] != string.Empty)
							{
								loadedVehiclePatrol.days[num] = loadedVehiclePatrol.days[num].ToLower();
								if (!list.Contains(loadedVehiclePatrol.days[num]))
								{
									MelonLogger.Warning("Vehicle Patrol Config '" + loadedVehiclePatrol.name + "' has invalid weekday: '" + loadedVehiclePatrol.days[num] + "'");
									loadedVehiclePatrol.days.RemoveAt(num);
								}
							}
							else
							{
								loadedVehiclePatrol.days.RemoveAt(num);
							}
						}
					}
				}
				catch (Exception ex)
				{
					vehiclePatrolsSerialized = new VehiclePatrolsSerialized();
					MelonLogger.Warning("Failed to read Vehicle Patrol config: " + ex);
				}
			}
			else
			{
				vehiclePatrolsSerialized = new VehiclePatrolsSerialized();
				vehiclePatrolsSerialized.loadedVehiclePatrols = new List<SerializedVehiclePatrol>();
				Save(vehiclePatrolsSerialized);
			}
			return vehiclePatrolsSerialized;
		}

		public static void Save(VehiclePatrolsSerialized config)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			try
			{
				JsonSerializerSettings val = new JsonSerializerSettings
				{
					ContractResolver = (IContractResolver)(object)new UnityContractResolver()
				};
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1, val);
				Directory.CreateDirectory(Path.GetDirectoryName(vehiclePatrolsConfig));
				File.WriteAllText(vehiclePatrolsConfig, contents);
				MelonLogger.Warning("    Vehicle Patrols config has been saved!");
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Vehicle Patrols config: " + ex);
			}
		}

		public static SentrysSerialized LoadSentryConfig()
		{
			SentrysSerialized sentrysSerialized;
			if (File.Exists(sentrysConfig))
			{
				try
				{
					sentrysSerialized = JsonConvert.DeserializeObject<SentrysSerialized>(File.ReadAllText(sentrysConfig));
					List<string> list = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
					foreach (SerializedSentry loadedSentry in sentrysSerialized.loadedSentrys)
					{
						loadedSentry.members = Mathf.Clamp(loadedSentry.members, 1, 2);
						loadedSentry.name = (string.IsNullOrEmpty(loadedSentry.name) ? "NACopsSentry " : loadedSentry.name);
						loadedSentry.intensityRequirement = Mathf.Clamp(loadedSentry.intensityRequirement, 0, 10);
						if (!TimeManager.IsValid24HourTime(loadedSentry.startTime.ToString()))
						{
							MelonLogger.Warning("Sentry Config '" + loadedSentry.name + "' has invalid start time");
							loadedSentry.startTime = 1900;
						}
						if (!TimeManager.IsValid24HourTime(loadedSentry.endTime.ToString()))
						{
							MelonLogger.Warning("Sentry Config '" + loadedSentry.name + "' has invalid end time");
							loadedSentry.endTime = 2330;
						}
						for (int num = loadedSentry.days.Count - 1; num != -1; num--)
						{
							if (loadedSentry.days[num] != string.Empty)
							{
								loadedSentry.days[num] = loadedSentry.days[num].ToLower();
								if (!list.Contains(loadedSentry.days[num]))
								{
									MelonLogger.Warning("Sentry Config '" + loadedSentry.name + "' has invalid weekday: '" + loadedSentry.days[num] + "'");
									loadedSentry.days.RemoveAt(num);
								}
							}
							else
							{
								loadedSentry.days.RemoveAt(num);
							}
						}
					}
				}
				catch (Exception ex)
				{
					sentrysSerialized = new SentrysSerialized();
					MelonLogger.Warning("Failed to read SentrysSerialized config: " + ex);
				}
			}
			else
			{
				sentrysSerialized = new SentrysSerialized();
				sentrysSerialized.loadedSentrys = new List<SerializedSentry>();
				Save(sentrysSerialized);
			}
			return sentrysSerialized;
		}

		public static void Save(SentrysSerialized config)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			try
			{
				JsonSerializerSettings val = new JsonSerializerSettings
				{
					ContractResolver = (IContractResolver)(object)new UnityContractResolver()
				};
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1, val);
				Directory.CreateDirectory(Path.GetDirectoryName(sentrysConfig));
				File.WriteAllText(sentrysConfig, contents);
				MelonLogger.Warning("    Sentry config has been saved!");
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Sentry config: " + ex);
			}
		}

		public static string SanitizeAndFormatName(string orgName)
		{
			string text = orgName;
			if (text != null)
			{
				text = text.Replace(" ", "_").ToLower();
				text = text.Replace(",", "");
				text = text.Replace(".", "");
				text = text.Replace("<", "");
				text = text.Replace(">", "");
				text = text.Replace(":", "");
				text = text.Replace("\"", "");
				text = text.Replace("/", "");
				text = text.Replace("\\", "");
				text = text.Replace("|", "");
				text = text.Replace("?", "");
				text = text.Replace("*", "");
			}
			return text + ".json";
		}

		public static PropertiesHeatSerialized LoadPropertyHeats()
		{
			string path = SanitizeAndFormatName(Singleton<LoadManager>.Instance.ActiveSaveInfo?.OrganisationName);
			PropertiesHeatSerialized propertiesHeatSerialized;
			if (File.Exists(Path.Combine(propertyHeatConfig, path)))
			{
				try
				{
					propertiesHeatSerialized = JsonConvert.DeserializeObject<PropertiesHeatSerialized>(File.ReadAllText(Path.Combine(propertyHeatConfig, path)));
				}
				catch (Exception ex)
				{
					propertiesHeatSerialized = new PropertiesHeatSerialized();
					propertiesHeatSerialized.loadedPropertyHeats = new List<PropertyHeat>();
					string[] array = new string[6] { "sweatshop", "bungalow", "storageunit", "dockswarehouse", "barn", "manor" };
					foreach (string propertyCode in array)
					{
						PropertyHeat propertyHeat = new PropertyHeat();
						propertyHeat.propertyCode = propertyCode;
						propertiesHeatSerialized.loadedPropertyHeats.Add(propertyHeat);
					}
					MelonLogger.Warning("Failed to read NACops Property Heat config: " + ex);
				}
			}
			else
			{
				MelonLogger.Warning("Missing NACops Property Heat config, creating directory and template.");
				propertiesHeatSerialized = new PropertiesHeatSerialized();
				Save(propertiesHeatSerialized, generateTemplate: true);
			}
			return propertiesHeatSerialized;
		}

		public static void Save(PropertiesHeatSerialized config, bool generateTemplate = false)
		{
			if (generateTemplate)
			{
				config.loadedPropertyHeats = new List<PropertyHeat>();
				string[] array = new string[6] { "sweatshop", "bungalow", "storageunit", "dockswarehouse", "barn", "manor" };
				foreach (string propertyCode in array)
				{
					PropertyHeat propertyHeat = new PropertyHeat();
					propertyHeat.propertyCode = propertyCode;
					config.loadedPropertyHeats.Add(propertyHeat);
				}
			}
			try
			{
				string path = SanitizeAndFormatName(Singleton<LoadManager>.Instance.ActiveSaveInfo?.OrganisationName);
				string path2 = Path.Combine(propertyHeatConfig, path);
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1);
				Directory.CreateDirectory(Path.GetDirectoryName(path2));
				File.WriteAllText(path2, contents);
				if (generateTemplate)
				{
					MelonLogger.Warning("    NACops Property Heat config, written to: " + propertyHeatConfig);
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Property Heat config: " + ex);
			}
		}

		public static ThresholdMappings LoadFrequencyConfig()
		{
			ThresholdMappings thresholdMappings;
			if (File.Exists(eventFrequencyConfig))
			{
				try
				{
					thresholdMappings = JsonConvert.DeserializeObject<ThresholdMappings>(File.ReadAllText(eventFrequencyConfig));
					foreach (MinMaxThreshold item in thresholdMappings.LethalCopFrequency)
					{
						if (item.MinOf < 0)
						{
							item.MinOf = 0;
						}
						if (item.Min >= item.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at LethalCopFreq Min value, must be smaller than Max value");
							if (item.Max > 0f)
							{
								item.Min = item.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item2 in thresholdMappings.LethalCopRange)
					{
						if (item2.MinOf < 0)
						{
							item2.MinOf = 0;
						}
						if (item2.Min >= item2.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at LethalCopRange Min value, must be smaller than Max value");
							if (item2.Max > 0f)
							{
								item2.Min = item2.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item3 in thresholdMappings.NearbyCrazyFrequency)
					{
						if (item3.MinOf < 0)
						{
							item3.MinOf = 0;
						}
						if (item3.Min >= item3.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at NearbyCrazFreq Min value, must be smaller than Max value");
							if (item3.Max > 0f)
							{
								item3.Min = item3.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item4 in thresholdMappings.NearbyCrazyRange)
					{
						if (item4.MinOf < 0)
						{
							item4.MinOf = 0;
						}
						if (item4.Min >= item4.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at NearbyCrazRange Min value, must be smaller than Max value");
							if (item4.Max > 0f)
							{
								item4.Min = item4.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item5 in thresholdMappings.PIFrequency)
					{
						if (item5.MinOf < 0)
						{
							item5.MinOf = 0;
						}
						if (item5.Min >= item5.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at PIFreq Min value, must be smaller than Max value");
							if (item5.Max > 0f)
							{
								item5.Min = item5.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item6 in thresholdMappings.SnitchProbability)
					{
						if (item6.MinOf < 0)
						{
							item6.MinOf = 0;
						}
						if (item6.Min >= item6.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at SnitchProbability Min value, must be smaller than Max value");
							if (item6.Max > 0f)
							{
								item6.Min = item6.Max * 0.5f;
							}
						}
					}
					foreach (MinMaxThreshold item7 in thresholdMappings.BuyBustProbability)
					{
						if (item7.MinOf < 0)
						{
							item7.MinOf = 0;
						}
						if (item7.Min >= item7.Max)
						{
							MelonLogger.Warning("Found invalid value in progression.json at BuyBustProbability Min value, must be smaller than Max value");
							if (item7.Max > 0f)
							{
								item7.Min = item7.Max * 0.5f;
							}
						}
					}
				}
				catch (Exception ex)
				{
					thresholdMappings = new ThresholdMappings();
					MelonLogger.Warning("Failed to read NACops Event Frequency config: " + ex);
				}
			}
			else
			{
				MelonLogger.Warning("Missing NACops Event Frequency config, creating directory and template.");
				thresholdMappings = new ThresholdMappings();
				Save(thresholdMappings);
			}
			return thresholdMappings;
		}

		public static void Save(ThresholdMappings config)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1);
				Directory.CreateDirectory(Path.GetDirectoryName(eventFrequencyConfig));
				File.WriteAllText(eventFrequencyConfig, contents);
				MelonLogger.Warning("    NACops Event Frequency config, written to: " + eventFrequencyConfig);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Event Frequency config: " + ex);
			}
		}

		public static RaidConfig LoadRaidConfig()
		{
			RaidConfig raidConfig;
			if (File.Exists(ConfigLoader.raidConfig))
			{
				try
				{
					raidConfig = JsonConvert.DeserializeObject<RaidConfig>(File.ReadAllText(ConfigLoader.raidConfig));
					raidConfig.TraverseToPropertySpeed = Mathf.Clamp(raidConfig.TraverseToPropertySpeed, 0.1f, 1f);
					raidConfig.ClearPropertySpeed = Mathf.Clamp(raidConfig.ClearPropertySpeed, 0.1f, 1f);
					raidConfig.MaxDestroyIters = Mathf.Clamp(raidConfig.MaxDestroyIters, 1, 10);
					raidConfig.RaidCopsCount = Mathf.Clamp(raidConfig.RaidCopsCount, 1, 10);
					raidConfig.DaysUntilCanRaid = Mathf.Clamp(raidConfig.DaysUntilCanRaid, 1, 20);
					raidConfig.PropertyHeatThreshold = Mathf.Clamp(raidConfig.PropertyHeatThreshold, 1, 100);
				}
				catch (Exception ex)
				{
					raidConfig = new RaidConfig();
					MelonLogger.Warning("Failed to read NACops Raid config: " + ex);
				}
			}
			else
			{
				MelonLogger.Warning("Missing NACops Raid config, creating directory and template.");
				raidConfig = new RaidConfig();
				Save(raidConfig);
			}
			return raidConfig;
		}

		public static void Save(RaidConfig config)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)config, (Formatting)1);
				Directory.CreateDirectory(Path.GetDirectoryName(raidConfig));
				File.WriteAllText(raidConfig, contents);
				MelonLogger.Warning("    NACops Raid config, written to: " + raidConfig);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("Failed to save NACops Raid config: " + ex);
			}
		}
	}
	public static class ConsoleModule
	{
		[Flags]
		public enum CommandSupport
		{
			None = 0,
			List = 1,
			Spawn = 2,
			SpawnNoIndex = 4,
			Visualize = 8,
			Build = 0x10
		}

		public abstract class ConsoleCommandBase
		{
			public virtual string Name { get; }

			public virtual CommandSupport SupportedMethods { get; }

			public virtual void List()
			{
				DebugModule.Log("Not implemented", "List");
			}

			public virtual void Spawn(int index)
			{
				DebugModule.Log("Not implemented", "Spawn");
			}

			public virtual void Visualize(int index)
			{
				DebugModule.Log("Not implemented", "Visualize");
			}

			public virtual void Build(string arg)
			{
				DebugModule.Log("Build Argument: " + arg + " Not implemented", "Build");
			}

			protected static void CleanVisual()
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				if (DebugModule.pathVisualizer != null && DebugModule.pathVisualizer.Count > 0)
				{
					foreach (GameObject item in DebugModule.pathVisualizer)
					{
						Object.Destroy((Object)(object)item);
					}
				}
				DebugModule.pathVisualizer.Clear();
				if ((Object)(object)DebugModule.lineRenderMat == (Object)null)
				{
					DebugModule.lineRenderMat = new Material(Shader.Find("Sprites/Default"));
				}
			}

			protected static void DrawPath(string name, Vector3[] points)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("Path_" + name);
				DebugModule.pathVisualizer.Add(val);
				LineRenderer obj = val.AddComponent<LineRenderer>();
				((Renderer)obj).material = DebugModule.lineRenderMat;
				obj.widthMultiplier = 0.5f;
				obj.startColor = Color.blue;
				obj.endColor = Color.red;
				obj.positionCount = points.Length;
				obj.SetPositions(points);
			}
		}

		public class FootPatrolTarget : ConsoleCommandBase
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass5_0
			{
				public PatrolInstance instance;

				public int originalStart;

				public int originalEnd;
			}

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

				private object <>2__current;

				public FootPatrolTarget <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0037: Expected O, but got Unknown
					//IL_0052: Unknown result type (might be due to invalid IL or missing references)
					//IL_007e: Unknown result type (might be due to invalid IL or missing references)
					//IL_008a: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					FootPatrolTarget footPatrolTarget = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						Transform centerPointTransform = Player.Local.CenterPointTransform;
						GameObject val = new GameObject("Path");
						DebugModule.pathVisualizer.Add(val);
						footPatrolTarget.recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
						LineRenderer val2 = val.AddComponent<LineRenderer>();
						((Renderer)val2).material = DebugModule.lineRenderMat;
						val2.widthMultiplier = 0.5f;
						val2.startColor = Color.blue;
						val2.endColor = Color.red;
						val2.positionCount = footPatrolTarget.recordedPathNodes.Count;
						val2.SetPositions(footPatrolTarget.recordedPathNodes.ToArray());
						while (NACops.registered && isBuilding)
						{
							if (Vector3.Distance(centerPointTransform.position, footPatrolTarget.recordedPathNodes[footPatrolTarget.recordedPathNodes.Count - 1]) > 6f)
							{
								footPatrolTarget.BuildNode(val2);
							}
						}
						<>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();
				}
			}

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

			public string currentPathName;

			public override string Name => "footpatrol";

			public override CommandSupport SupportedMethods => CommandSupport.List | CommandSupport.Spawn | CommandSupport.Visualize | CommandSupport.Build;

			public override void List()
			{
				string text = "";
				int num = 0;
				text += "\nIndex: Name";
				foreach (PatrolInstance key in FootPatrolGenerator.generatedPatrolInstances.Keys)
				{
					text += $"\n{num}: {((Object)key.Route).name}";
					num++;
				}
				text += "\n-------";
				DebugModule.Log(text, "List");
			}

			public override void Spawn(int index)
			{
				<>c__DisplayClass5_0 CS$<>8__locals0 = new <>c__DisplayClass5_0();
				List<PatrolInstance> list = FootPatrolGenerator.generatedPatrolInstances.Keys.ToList();
				if (index < list.Count)
				{
					CS$<>8__locals0.instance = list[index];
					if (CS$<>8__locals0.instance.ActiveGroup != null)
					{
						DebugModule.Log("Foot patrol group is already active", "Spawn");
						return;
					}
					CS$<>8__locals0.originalStart = CS$<>8__locals0.instance.StartTime;
					CS$<>8__locals0.originalEnd = CS$<>8__locals0.instance.EndTime;
					CS$<>8__locals0.instance.StartTime = NetworkSingleton<TimeManager>.Instance.CurrentTime;
					CS$<>8__locals0.instance.EndTime = TimeManager.AddMinutesTo24HourTime(CS$<>8__locals0.originalStart, 240);
					CS$<>8__locals0.instance.StartPatrol();
					DebugModule.Log("Patrol " + ((Object)CS$<>8__locals0.instance.Route).name + " Spawned", "Spawn");
					NACops.coros.Add(MelonCoroutines.Start(EndSoon()));
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d))]
				IEnumerator EndSoon()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}

			public override void Visualize(int index)
			{
				ConsoleCommandBase.CleanVisual();
				List<PatrolInstance> list = FootPatrolGenerator.generatedPatrolInstances.Keys.ToList();
				if (index >= 0 && index < list.Count)
				{
					FootPatrolRoute route = list[index].Route;
					Vector3[] points = route.Waypoints.Select((Transform waypoint) => waypoint.position + Vector3.up * 8f).ToArray();
					ConsoleCommandBase.DrawPath(((Object)route).name, points);
					DebugModule.Log("Patrol " + ((Object)route).name + " Visualized", "Visualize");
				}
			}

			public override void Build(string arg)
			{
				if (arg.ToLower() == "start")
				{
					BuildStart();
				}
				else if (isBuilding)
				{
					BuildEnd();
				}
			}

			public void BuildStart()
			{
				if (isBuilding)
				{
					DebugModule.Log("Already building a path or a sentry!\n    Use: nacops build " + Name + " stop\n    to stop building", "BuildStart");
					return;
				}
				isBuilding = true;
				currentPathName = $"{Name}_{Guid.NewGuid()}";
				DebugModule.Log("Started building path with name " + currentPathName + "\nWalk around to create new path nodes!", "BuildStart");
				NACops.coros.Add(MelonCoroutines.Start(FollowPlayer()));
			}

			[IteratorStateMachine(typeof(<FollowPlayer>d__11))]
			public IEnumerator FollowPlayer()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <FollowPlayer>d__11(0)
				{
					<>4__this = this
				};
			}

			public void BuildNode(LineRenderer lineRenderer)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
				lineRenderer.positionCount = recordedPathNodes.Count;
				lineRenderer.SetPositions(recordedPathNodes.ToArray());
			}

			public void BuildEnd()
			{
				//IL_00f4: 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_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				isBuilding = false;
				ConsoleCommandBase.CleanVisual();
				if (recordedPathNodes.Count == 0)
				{
					DebugModule.Log("No recorded nodes found.", "BuildEnd");
					return;
				}
				if (recordedPathNodes.Count < 4)
				{
					DebugModule.Log("Build more path nodes to save.", "BuildEnd");
					recordedPathNodes.Clear();
					return;
				}
				SerializedFootPatrol serializedFootPatrol = new SerializedFootPatrol();
				serializedFootPatrol.startTime = 1900;
				serializedFootPatrol.endTime = 500;
				serializedFootPatrol.members = 1;
				serializedFootPatrol.intensityRequirement = 1;
				serializedFootPatrol.onlyIfCurfew = false;
				serializedFootPatrol.name = currentPathName;
				serializedFootPatrol.days = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
				List<Vector3> list = new List<Vector3>();
				list.Add(recordedPathNodes[0]);
				foreach (Vector3 recordedPathNode in recordedPathNodes)
				{
					if (Vector3.Distance(recordedPathNode, list[list.Count - 1]) > 24f)
					{
						list.Add(recordedPathNode);
					}
				}
				serializedFootPatrol.waypoints = new List<Vector3>(list);
				FootPatrolGenerator.serPatrols.loadedPatrols.Add(serializedFootPatrol);
				DebugModule.Log("Finished building: " + currentPathName, "BuildEnd");
				DebugModule.Log($"Recorded path nodes: {recordedPathNodes.Count}\n    Reload the game to apply changes.", "BuildEnd");
				ConfigLoader.Save(FootPatrolGenerator.serPatrols);
				recordedPathNodes.Clear();
			}
		}

		public class VehiclePatrolTarget : ConsoleCommandBase
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass5_0
			{
				public VehiclePatrolInstance instance;

				public int originalStart;
			}

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

				private object <>2__current;

				public VehiclePatrolTarget <>4__this;

				private Transform <tr>5__2;

				private LineRenderer <lineRenderer>5__3;

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

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

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

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

				private bool MoveNext()
				{
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0044: Expected O, but got Unknown
					//IL_005f: Unknown result type (might be due to invalid IL or missing references)
					//IL_009b: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
					//IL_0104: Unknown result type (might be due to invalid IL or missing references)
					//IL_011c: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					VehiclePatrolTarget vehiclePatrolTarget = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<tr>5__2 = Player.Local.CenterPointTransform;
						GameObject val = new GameObject("Path");
						DebugModule.pathVisualizer.Add(val);
						vehiclePatrolTarget.recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
						<lineRenderer>5__3 = val.AddComponent<LineRenderer>();
						((Renderer)<lineRenderer>5__3).material = DebugModule.lineRenderMat;
						<lineRenderer>5__3.widthMultiplier = 0.5f;
						<lineRenderer>5__3.startColor = Color.blue;
						<lineRenderer>5__3.endColor = Color.red;
						<lineRenderer>5__3.positionCount = vehiclePatrolTarget.recordedPathNodes.Count;
						<lineRenderer>5__3.SetPositions(vehiclePatrolTarget.recordedPathNodes.ToArray());
						goto IL_0139;
					}
					case 1:
						<>1__state = -1;
						if (Vector3.Distance(<tr>5__2.position, vehiclePatrolTarget.recordedPathNodes[vehiclePatrolTarget.recordedPathNodes.Count - 1]) > 6f)
						{
							vehiclePatrolTarget.BuildNode(<lineRenderer>5__3);
						}
						goto IL_0139;
					case 2:
						{
							<>1__state = -1;
							return false;
						}
						IL_0139:
						if (NACops.registered && isBuilding)
						{
							<>2__current = NACops.Wait1;
							<>1__state = 1;
							return true;
						}
						<>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 List<Vector3> recordedPathNodes = new List<Vector3>();

			public string currentPathName;

			public override string Name => "vehiclepatrol";

			public override CommandSupport SupportedMethods => CommandSupport.List | CommandSupport.Spawn | CommandSupport.Visualize | CommandSupport.Build;

			public override void List()
			{
				string text = "";
				int num = 0;
				text += "\nIndex: Name";
				foreach (VehiclePatrolInstance key in VehiclePatrolGenerator.generatedVehiclePatrolInstances.Keys)
				{
					text += $"\n{num}: {((Object)key.Route).name}";
					num++;
				}
				text += "\n-------";
				DebugModule.Log(text, "List");
			}

			public override void Spawn(int index)
			{
				<>c__DisplayClass5_0 CS$<>8__locals0 = new <>c__DisplayClass5_0();
				List<VehiclePatrolInstance> list = VehiclePatrolGenerator.generatedVehiclePatrolInstances.Keys.ToList();
				if (index < list.Count)
				{
					CS$<>8__locals0.instance = list[index];
					if ((Object)(object)CS$<>8__locals0.instance.activeOfficer != (Object)null)
					{
						DebugModule.Log("Vehicle patrol is already active", "Spawn");
						return;
					}
					CS$<>8__locals0.originalStart = CS$<>8__locals0.instance.StartTime;
					CS$<>8__locals0.instance.StartTime = NetworkSingleton<TimeManager>.Instance.CurrentTime;
					CS$<>8__locals0.instance.StartPatrol();
					DebugModule.Log("Vehicle Patrol " + ((Object)CS$<>8__locals0.instance.Route).name + " Spawned", "Spawn");
					NACops.coros.Add(MelonCoroutines.Start(EndSoon()));
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d))]
				IEnumerator EndSoon()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}

			public override void Visualize(int index)
			{
				ConsoleCommandBase.CleanVisual();
				List<VehiclePatrolInstance> list = VehiclePatrolGenerator.generatedVehiclePatrolInstances.Keys.ToList();
				if (index >= 0 && index < list.Count)
				{
					VehiclePatrolRoute route = list[index].Route;
					Vector3[] points = route.Waypoints.Select((Transform waypoint) => waypoint.position + Vector3.up * 8f).ToArray();
					ConsoleCommandBase.DrawPath(((Object)route).name, points);
					DebugModule.Log("Veicle Patrol " + ((Object)route).name + " Visualized", "Visualize");
				}
			}

			public override void Build(string arg)
			{
				if (arg.ToLower() == "start")
				{
					BuildStart();
				}
				else if (isBuilding)
				{
					BuildEnd();
				}
			}

			public void BuildStart()
			{
				if (isBuilding)
				{
					DebugModule.Log("Already building a path or a sentry!\n    Use: nacops build " + Name + " stop\n    to stop building", "BuildStart");
					return;
				}
				isBuilding = true;
				currentPathName = $"{Name}_{Guid.NewGuid()}";
				DebugModule.Log("Started building path with name " + currentPathName + "\nWalk on the road to create new path nodes!", "BuildStart");
				NACops.coros.Add(MelonCoroutines.Start(FollowPlayer()));
			}

			[IteratorStateMachine(typeof(<FollowPlayer>d__11))]
			public IEnumerator FollowPlayer()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <FollowPlayer>d__11(0)
				{
					<>4__this = this
				};
			}

			public void BuildNode(LineRenderer lineRenderer)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
				lineRenderer.positionCount = recordedPathNodes.Count;
				lineRenderer.SetPositions(recordedPathNodes.ToArray());
			}

			public void BuildEnd()
			{
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				isBuilding = false;
				ConsoleCommandBase.CleanVisual();
				if (recordedPathNodes.Count == 0)
				{
					DebugModule.Log("No recorded nodes found.", "BuildEnd");
					return;
				}
				if (recordedPathNodes.Count < 4)
				{
					DebugModule.Log("Build more path nodes to save.", "BuildEnd");
					recordedPathNodes.Clear();
					return;
				}
				SerializedVehiclePatrol serializedVehiclePatrol = new SerializedVehiclePatrol();
				serializedVehiclePatrol.startTime = 1900;
				serializedVehiclePatrol.intensityRequirement = 1;
				serializedVehiclePatrol.onlyIfCurfew = false;
				serializedVehiclePatrol.name = currentPathName;
				serializedVehiclePatrol.days = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
				List<Vector3> list = new List<Vector3>();
				list.Add(recordedPathNodes[0]);
				foreach (Vector3 recordedPathNode in recordedPathNodes)
				{
					if (Vector3.Distance(recordedPathNode, list[list.Count - 1]) > 24f)
					{
						list.Add(recordedPathNode);
					}
				}
				serializedVehiclePatrol.waypoints = new List<Vector3>(list);
				VehiclePatrolGenerator.serVehiclePatrols.loadedVehiclePatrols.Add(serializedVehiclePatrol);
				DebugModule.Log("Finished building: " + currentPathName, "BuildEnd");
				DebugModule.Log($"Recorded path nodes: {recordedPathNodes.Count}\n    Reload the game to apply changes.", "BuildEnd");
				ConfigLoader.Save(VehiclePatrolGenerator.serVehiclePatrols);
				recordedPathNodes.Clear();
			}
		}

		public class SentryTarget : ConsoleCommandBase
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass5_0
			{
				public SentryInstance instance;

				public int originalStart;

				public int originalEnd;
			}

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

				private object <>2__current;

				public SentryTarget <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					//IL_0126: 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_0138: Unknown result type (might be due to invalid IL or missing references)
					//IL_013d: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					SentryTarget sentryTarget = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						sentryTarget.recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
						isBuilding = false;
						if (sentryTarget.recordedPathNodes.Count == 0)
						{
							DebugModule.Log("No recorded nodes found.", "BuildEnd");
							return false;
						}
						if (sentryTarget.recordedPathNodes.Count != 2)
						{
							DebugModule.Log("Build more sentry nodes to save.", "BuildEnd");
							sentryTarget.recordedPathNodes.Clear();
							return false;
						}
						SerializedSentry item = new SerializedSentry
						{
							startTime = 1900,
							endTime = 500,
							members = 1,
							intensityRequirement = 1,
							onlyIfCurfew = false,
							name = sentryTarget.currentPathName,
							days = new List<string> { "mon", "tue", "wed", "thu", "fri", "sat", "sun" },
							standPosition1 = sentryTarget.recordedPathNodes[0],
							standPosition2 = sentryTarget.recordedPathNodes[1]
						};
						SentryGenerator.serSentries.loadedSentrys.Add(item);
						DebugModule.Log("Finished building: " + sentryTarget.currentPathName, "BuildEnd");
						DebugModule.Log($"Recorded path nodes: {sentryTarget.recordedPathNodes.Count}\n    Reload the game to apply changes.", "BuildEnd");
						ConfigLoader.Save(SentryGenerator.serSentries);
						sentryTarget.recordedPathNodes.Clear();
						<>2__current = NACops.Wait5;
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -1;
						ConsoleCommandBase.CleanVisual();
						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();
				}
			}

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

			public string currentPathName;

			public override string Name => "sentry";

			public override CommandSupport SupportedMethods => CommandSupport.List | CommandSupport.Spawn | CommandSupport.Visualize | CommandSupport.Build;

			public override void List()
			{
				string text = "";
				int num = 0;
				text += "\nIndex: Name";
				foreach (SentryInstance key in SentryGenerator.generatedSentryInstances.Keys)
				{
					text += $"\n{num}: {((Object)((Component)key._potentialLocations[0]).gameObject).name}";
					num++;
				}
				text += "\n-------";
				DebugModule.Log(text, "List");
			}

			public override void Spawn(int index)
			{
				<>c__DisplayClass5_0 CS$<>8__locals0 = new <>c__DisplayClass5_0();
				List<SentryInstance> list = SentryGenerator.generatedSentryInstances.Keys.ToList();
				if (index < list.Count)
				{
					CS$<>8__locals0.instance = list[index];
					if (CS$<>8__locals0.instance._potentialLocations[0].AssignedOfficers.Count > 0)
					{
						DebugModule.Log("Sentry is already active", "Spawn");
						return;
					}
					CS$<>8__locals0.originalStart = CS$<>8__locals0.instance.StartTime;
					CS$<>8__locals0.originalEnd = CS$<>8__locals0.instance.EndTime;
					CS$<>8__locals0.instance.StartTime = NetworkSingleton<TimeManager>.Instance.CurrentTime;
					CS$<>8__locals0.instance.EndTime = TimeManager.AddMinutesTo24HourTime(CS$<>8__locals0.originalStart, 240);
					CS$<>8__locals0.instance.StartEntry();
					DebugModule.Log("Sentry " + ((Object)((Component)CS$<>8__locals0.instance._potentialLocations[0]).gameObject).name + " Spawned", "Spawn");
					NACops.coros.Add(MelonCoroutines.Start(EndSoon()));
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d))]
				IEnumerator EndSoon()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass5_0.<<Spawn>g__EndSoon|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}

			public override void Visualize(int index)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: 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_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				ConsoleCommandBase.CleanVisual();
				List<SentryInstance> list = SentryGenerator.generatedSentryInstances.Keys.ToList();
				if (index >= 0 && index < list.Count)
				{
					SentryInstance val = list[index];
					for (int i = 0; i < val._potentialLocations[0].Routes.Count; i++)
					{
						Vector3 position = val._potentialLocations[0].Routes[0].RoutePoints[i].position;
						Vector3[] points = (Vector3[])(object)new Vector3[2]
						{
							position,
							position + Vector3.up * 8f
						};
						ConsoleCommandBase.DrawPath($"{((Object)((Component)val._potentialLocations[0]).gameObject).name}_{i}", points);
					}
					DebugModule.Log("Sentry " + ((Object)((Component)val._potentialLocations[0]).gameObject).name + " Visualized", "Visualize");
				}
			}

			public override void Build(string arg)
			{
				if (arg.ToLower() == "start")
				{
					BuildStart();
				}
				else if (isBuilding)
				{
					NACops.coros.Add(MelonCoroutines.Start(BuildEnd()));
				}
			}

			public void BuildStart()
			{
				if (isBuilding)
				{
					DebugModule.Log("Already building a path or sentry!\n    Use: nacops build " + Name + " stop\n    to stop building", "BuildStart");
					return;
				}
				isBuilding = true;
				currentPathName = $"{Name}_{Guid.NewGuid()}";
				DebugModule.Log(currentPathName + ": Set 1st Sentry Point\n    Walk to 2nd sentry point and type:\nnacops build " + Name + " stop", "BuildStart");
				MakeVertBeam();
			}

			public void MakeVertBeam()
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: 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)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				Transform centerPointTransform = Player.Local.CenterPointTransform;
				GameObject val = new GameObject("Path");
				DebugModule.pathVisualizer.Add(val);
				recordedPathNodes.Add(Player.Local.CenterPointTransform.position);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				((Renderer)val2).material = DebugModule.lineRenderMat;
				val2.widthMultiplier = 0.5f;
				val2.startColor = Color.blue;
				val2.endColor = Color.red;
				val2.positionCount = 2;
				Vector3[] positions = (Vector3[])(object)new Vector3[2]
				{
					centerPointTransform.position,
					centerPointTransform.position + Vector3.up * 5f
				};
				val2.SetPositions(positions);
			}

			[IteratorStateMachine(typeof(<BuildEnd>d__12))]
			public IEnumerator BuildEnd()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <BuildEnd>d__12(0)
				{
					<>4__this = this
				};
			}
		}

		public class RaidTarget : ConsoleCommandBase
		{
			public override string Name => "raid";

			public override CommandSupport SupportedMethods => CommandSupport.List | CommandSupport.Spawn;

			public override void List()
			{
				lock (NACops.heatConfigLock)
				{
					List<PropertyHeat> list = new List<PropertyHeat>(NACops.heatConfig);
					string text = "";
					int num = 0;
					text += "\nIndex: Name";
					foreach (PropertyHeat item in list)
					{
						text += $"\n{num}: {item.propertyCode}\n    DaysSinceRaid: {item.daysSinceLastRaid}\n    Heat: {item.propertyHeat}";
						num++;
					}
					text += "\n-------";
					DebugModule.Log(text, "List");
				}
			}

			public override void Spawn(int index)
			{
				if (index < 0 || index >= NACops.heatConfig.Count)
				{
					return;
				}
				Property val = null;
				foreach (Property property in Property.Properties)
				{
					if (property.PropertyCode == NACops.heatConfig[index].propertyCode)
					{
						val = property;
					}
				}
				if (Object.op_Implicit((Object)(object)val))
				{
					if ((Object)(object)val.NPCSpawnPoint == (Object)null)
					{
						DebugModule.Log("No valid destination for property: " + val.propertyName, "Spawn");
					}
					else if (val is Business)
					{
						DebugModule.Log("Cant start raid on a business", "Spawn");
					}
					else
					{
						NACops.coros.Add(MelonCoroutines.Start(RaidPropertyEvent.BeginRaidEvent(val)));
					}
				}
			}

			public override void Visualize(int index)
			{
				DebugModule.Log("Not supported", "Visualize");
			}
		}

		public class InvestigatorTarget : ConsoleCommandBase
		{
			public override string Name => "investigator";

			public override CommandSupport SupportedMethods => CommandSupport.SpawnNoIndex;

			public override void List()
			{
				DebugModule.Log("Not supported", "List");
			}

			public override void Spawn(int index)
			{
				DebugModule.Log("Spawning Private Investigator", "Spawn");
				NACops.coros.Add(MelonCoroutines.Start(PrivateInvestigator.HandlePIMonitor()));
			}

			public override void Visualize(int index)
			{
				DebugModule.Log("Not supported", "Visualize");
			}
		}

		public static bool isBuilding = false;

		public static bool isLoggingEnabled = false;

		public static readonly HashSet<string> ConsoleMethodNames = new HashSet<string> { "Help", "List", "Spawn", "Visualize", "BuildStart", "BuildEnd", "RunCommand" };
	}
	public static class DebugModule
	{
		public static int origCount = 0;

		public static Material lineRenderMat;

		public static List<GameObject> pathVisualizer = new List<GameObject>();

		public static Dictionary<string, ConsoleModule.ConsoleCommandBase> consoleTargets = new Dictionary<string, ConsoleModule.ConsoleCommandBase>
		{
			{
				"footpatrol",
				new ConsoleModule.FootPatrolTarget()
			},
			{
				"vehiclepatrol",
				new ConsoleModule.VehiclePatrolTarget()
			},
			{
				"sentry",
				new ConsoleModule.SentryTarget()
			},
			{
				"raid",
				new ConsoleModule.RaidTarget()
			},
			{
				"investigator",
				new ConsoleModule.InvestigatorTarget()
			}
		};

		public static void Log(string msg, [CallerMemberName] string memberName = "")
		{
			if (ConsoleModule.isLoggingEnabled || ConsoleModule.ConsoleMethodNames.Contains(memberName))
			{
				MelonLogger.Msg("[" + memberName + "] " + msg);
			}
		}

		public static void RunCommand(List<string> args)
		{
			if (args.Count == 2 && args[1].ToLower() == "help")
			{
				Help();
				return;
			}
			if (args.Count == 3 && args[1].ToLower() == "enable" && args[2].ToLower() == "logs")
			{
				ConsoleModule.isLoggingEnabled = true;
				return;
			}
			if (args.Count < 3)
			{
				Log("Usage: nacops (action) (target) (index or argument)\n    Try: nacops help", "RunCommand");
				return;
			}
			string text = args[1].ToLower();
			string text2 = args[2].ToLower();
			int result = ((args.Count > 3 && int.TryParse(args[3], out result)) ? result : (-1));
			if (result == -1 && args.Count > 3 && !(args[3].ToLower() == "start"))
			{
				_ = args[3].ToLower() == "stop";
			}
			if (!consoleTargets.TryGetValue(text2, out var value))
			{
				Log("Unknown command target '" + text2 + "'", "RunCommand");
				return;
			}
			ConsoleModule.CommandSupport commandSupport = text switch
			{
				"list" => ConsoleModule.CommandSupport.List, 
				"spawn" => ConsoleModule.CommandSupport.Spawn | ConsoleModule.CommandSupport.SpawnNoIndex, 
				"visualize" => ConsoleModule.CommandSupport.Visualize, 
				"build" => ConsoleModule.CommandSupport.Build, 
				_ => ConsoleModule.CommandSupport.None, 
			};
			if ((value.SupportedMethods & commandSupport) == 0)
			{
				Log($"Command target '{text2}' does not support requested method '{commandSupport}'", "RunCommand");
				return;
			}
			switch (commandSupport)
			{
			case ConsoleModule.CommandSupport.List:
				value.List();
				break;
			case ConsoleModule.CommandSupport.Spawn | ConsoleModule.CommandSupport.SpawnNoIndex:
				value.Spawn(result);
				break;
			case ConsoleModule.CommandSupport.Visualize:
				value.Visualize(result);
				break;
			case ConsoleModule.CommandSupport.Build:
				value.Build(args[3]);
				break;
			}
		}

		public static void Help()
		{
			string text = "";
			text += "\nSupported Commands:";
			text += "\n\n# ENABLE FULL LOGGING";
			text += "\nnacops enable logs";
			foreach (ConsoleModule.ConsoleCommandBase value in consoleTargets.Values)
			{
				text = text + "\n\n# " + value.Name.ToUpper();
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.List))
				{
					text = text + "\nnacops list " + value.Name;
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.Spawn))
				{
					text = text + "\nnacops spawn " + value.Name + " (index)";
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.SpawnNoIndex))
				{
					text = text + "\nnacops spawn " + value.Name;
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.Visualize))
				{
					text = text + "\nnacops visualize " + value.Name + " (index)";
				}
				if (value.SupportedMethods.HasFlag(ConsoleModule.CommandSupport.Build))
				{
					text = text + "\nnacops build " + value.Name + " start";
					text = text + "\nnacops build " + value.Name + " stop";
				}
			}
			Log(text, "Help");
		}
	}
	[HarmonyPatch(typeof(Console), "SubmitCommand", new Type[] { typeof(List<string>) })]
	public static class Console_SubmitCommand_ListString_Patch
	{
		public static bool Prefix(Console __instance, List<string> args)
		{
			if (args.Count == 0)
			{
				return true;
			}
			if (args[0].ToLower() == "nacops")
			{
				DebugModule.RunCommand(args);
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Console), "SubmitCommand", new Type[] { typeof(string) })]
	public static class Console_SubmitCommand_String_Patch
	{
		public static bool Prefix(Console __instance, string args)
		{
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeProduct")]
	public static class Player_ConsumeProduct_Patch
	{
		[CompilerGenerated]
		private sealed class <ApprehenderOfficerClear>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

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

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

			[DebuggerHidden]
			public <ApprehenderOfficerClear>d__3(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 ((Object)(object)offc == (Object)null)
					{
						return false;
					}
					<>2__current = NACops.Wait30;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					DebugModule.Log(" apprehender clear", "ApprehenderOfficerClear");
					if (NACops.currentDrugApprehender.Contains(offc))
					{
						NACops.currentDrugApprehender.Remove(offc);
					}
					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 <DrugConsumedCoro>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ProductItemInstance product;

			public Player player;

			private PoliceOfficer <noticeOfficer>5__2;

			private float <smallestDistance>5__3;

			private bool <direct>5__4;

			private bool <apprehending>5__5;

			private HashSet<PoliceOfficer>.Enumerator <>7__wrap5;

			private PoliceOfficer <offc>5__7;

			private int <i>5__8;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<noticeOfficer>5__2 = null;
				<>7__wrap5 = default(HashSet<PoliceOfficer>.Enumerator);
				<offc>5__7 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0381: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_027c: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0491: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if (!NACops.currentConfig.WeedInvestigator)
						{
							return false;
						}
						bool flag = false;
						bool num2 = product is WeedInstance;
						bool flag2 = product is MethInstance;
						bool flag3 = product is CocaineInstance;
						bool flag4 = product is ShroomInstance;
						flag = num2 || flag2 || flag3 || flag4;
						DebugModule.Log("Is Supported Instance for Apprehender: " + flag, "DrugConsumedCoro");
						if (flag)
						{
							DebugModule.Log("Instance casted, check officers count: " + NACops.allActiveOfficers.Count, "DrugConsumedCoro");
							<noticeOfficer>5__2 = null;
							<smallestDistance>5__3 = 49f;
							<direct>5__4 = false;
							<>7__wrap5 = NACops.allActiveOfficers.GetEnumerator();
							<>1__state = -3;
							goto IL_02d7;
						}
						goto IL_0653;
					}
					case 1:
						<>1__state = -3;
						if (!BaseUtility.GUIDInUse.Contains(((NPC)<offc>5__7).BakedGUID) && !NACops.currentDrugApprehender.Contains(<offc>5__7) && !NACops.currentSummoned.Contains(<offc>5__7) && !(Vector3.Distance(((Component)<offc>5__7).transform.position, ((Component)player).transform.position) > 50f) && !((NPC)<offc>5__7).Health.IsDead && !((NPC)<offc>5__7).Health.IsKnockedOut)
						{
							if (((NPC)<offc>5__7).Awareness.VisionCone.IsPlayerVisible(player) && ((NPC)<offc>5__7).Movement.CanMove() && !((NPC)<offc>5__7).IsInVehicle && !((NPC)<offc>5__7).isInBuilding)
							{
								<offc>5__7.BeginFootPursuit(player.PlayerCode);
								NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(3, player)));
								<direct>5__4 = true;
								DebugModule.Log("Apprehend immediate direct", "DrugConsumedCoro");
								goto IL_02e7;
							}
							float num = Vector3.Distance(((Component)<offc>5__7).transform.position, ((Component)player).transform.position);
							if (num < <smallestDistance>5__3 && !((NPC)<offc>5__7).IsInVehicle && !((NPC)<offc>5__7).isInBuilding)
							{
								<smallestDistance>5__3 = num;
								<noticeOfficer>5__2 = <offc>5__7;
							}
							<offc>5__7 = null;
						}
						goto IL_02d7;
					case 2:
						<>1__state = -1;
						if (((NPC)<noticeOfficer>5__2).Awareness.VisionCone.IsPlayerVisible(player))
						{
							DebugModule.Log("Apprehend immediate candidate", "DrugConsumedCoro");
							<noticeOfficer>5__2.BeginBodySearch(player.PlayerCode);
							NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(3, player)));
							<apprehending>5__5 = true;
						}
						if ((Object)(object)<noticeOfficer>5__2 != (Object)null && !<apprehending>5__5)
						{
							<i>5__8 = 0;
							goto IL_0640;
						}
						goto IL_064c;
					case 3:
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						if (!((NPC)<noticeOfficer>5__2).Health.IsDead && !((NPC)<noticeOfficer>5__2).Health.IsKnockedOut)
						{
							if (!((NPC)<noticeOfficer>5__2).Awareness.VisionCone.IsPlayerVisible(player))
							{
								<>2__current = NACops.Wait05;
								<>1__state = 4;
								return true;
							}
							<noticeOfficer>5__2.BeginBodySearch(player.PlayerCode);
							if (Random.Range(1f, 0f) > 0.8f)
							{
								NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(1, player)));
							}
						}
						goto IL_064c;
					case 4:
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						if (!((NPC)<noticeOfficer>5__2).Health.IsDead && !((NPC)<noticeOfficer>5__2).Health.IsKnockedOut)
						{
							((NPC)<noticeOfficer>5__2).Movement.SetDestination(player.CenterPointTransform.position);
							<>2__current = NACops.Wait1;
							<>1__state = 5;
							return true;
						}
						goto IL_064c;
					case 5:
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						if (!((NPC)<noticeOfficer>5__2).Health.IsDead && !((NPC)<noticeOfficer>5__2).Health.IsKnockedOut)
						{
							<i>5__8++;
							goto IL_0640;
						}
						goto IL_064c;
					case 6:
						{
							<>1__state = -1;
							return false;
						}
						IL_064c:
						<noticeOfficer>5__2 = null;
						goto IL_0653;
						IL_0640:
						if (<i>5__8 <= 6)
						{
							DebugModule.Log("Apprehend Search suspect", "DrugConsumedCoro");
							if (!NACops.registered)
							{
								return false;
							}
							if (<i>5__8 <= 3 || !(Random.Range(1f, 0f) > 0.95f))
							{
								((NPC)<noticeOfficer>5__2).Movement.FacePoint(player.CenterPointTransform.position, 0.3f);
								<>2__current = NACops.Wait05;
								<>1__state = 3;
								return true;
							}
						}
						goto IL_064c;
						IL_0653:
						DebugModule.Log("evaluate apprehender end", "DrugConsumedCoro");
						evaluating = false;
						<>2__current = null;
						<>1__state = 6;
						return true;
						IL_02d7:
						if (<>7__wrap5.MoveNext())
						{
							<offc>5__7 = <>7__wrap5.Current;
							<>2__current = NACops.Wait01;
							<>1__state = 1;
							return true;
						}
						goto IL_02e7;
						IL_02e7:
						<>m__Finally1();
						<>7__wrap5 = default(HashSet<PoliceOfficer>.Enumerator);
						if (((Object)(object)<noticeOfficer>5__2 == (Object)null) | <direct>5__4)
						{
							DebugModule.Log("No apprehender candidate found", "DrugConsumedCoro");
							evaluating = false;
							return false;
						}
						NACops.currentDrugApprehender.Add(<noticeOfficer>5__2);
						DebugModule.Log("Proceed apprehender candidate", "DrugConsumedCoro");
						NACops.coros.Add(MelonCoroutines.Start(ApprehenderOfficerClear(<noticeOfficer>5__2)));
						<apprehending>5__5 = false;
						((NPC)<noticeOfficer>5__2).Movement.FacePoint(((Component)player).transform.position, 0.4f);
						<>2__current = NACops.Wait05;
						<>1__state = 2;
						return true;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

		public static bool evaluating;

		public static bool Prefix(Player __instance, ProductItemInstance product)
		{
			DebugModule.Log("ConsumePrefix", "Prefix");
			if (!evaluating && NACops.currentDrugApprehender.Count < 1)
			{
				evaluating = true;
				DebugModule.Log("CorosBegin", "Prefix");
				NACops.coros.Add(MelonCoroutines.Start(DrugConsumedCoro(__instance, product)));
			}
			return true;
		}

		[IteratorStateMachine(typeof(<DrugConsumedCoro>d__2))]
		public static IEnumerator DrugConsumedCoro(Player player, ProductItemInstance product)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DrugConsumedCoro>d__2(0)
			{
				player = player,
				product = product
			};
		}

		[IteratorStateMachine(typeof(<ApprehenderOfficerClear>d__3))]
		public static IEnumerator ApprehenderOfficerClear(PoliceOfficer offc)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApprehenderOfficerClear>d__3(0)
			{
				offc = offc
			};
		}
	}
	public static class LethalCops
	{
		[CompilerGenerated]
		private sealed class <RunNearbyLethalCops>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private float <minDistance>5__2;

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

			private Player <player>5__4;

			private PoliceOfficer <officer>5__5;

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

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

			[DebuggerHidden]
			public <RunNearbyLethalCops>d__6(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();
					}
				}
				<>7__wrap2 = default(List<Player>.Enumerator);
				<player>5__4 = null;
				<officer>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Expected O, but got Unknown
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Expected O, but got Unknown
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						if (!NACops.networkManager.IsServer)
						{
							result = false;
							break;
						}
						(float min, float max) tuple3 = ThresholdUtils.Evaluate(NACops.thresholdConfig.LethalCopFrequency, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
						minWait = tuple3.min;
						maxWait = tuple3.max;
						randWaits = new List<WaitForSeconds>
						{
							new WaitForSeconds(Random.Range(minWait, maxWait)),
							new WaitForSeconds(Random.Range(minWait, maxWait)),
							new WaitForSeconds(Random.Range(minWait, maxWait))
						};
						DebugModule.Log("Nearby Lethal Cop Enabled", "RunNearbyLethalCops");
						goto IL_00cf;
					}
					case 1:
					{
						<>1__state = -1;
						if (!NACops.registered)
						{
							result = false;
							break;
						}
						var (num, num2) = ThresholdUtils.Evaluate(NACops.thresholdConfig.LethalCopFrequency, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
						if (num != minWait || num2 != maxWait)
						{
							randWaits.Clear();
							for (int i = 0; i < 3; i++)
							{
								randWaits.Add(new WaitForSeconds(Random.Range(num, num2)));
							}
						}
						(float min, float max) tuple2 = ThresholdUtils.Evaluate(NACops.thresholdConfig.LethalCopRange, (int)NetworkSingleton<MoneyManager>.Instance.LifetimeEarnings);
						minRange = tuple2.min;
						maxRange = tuple2.max;
						<minDistance>5__2 = Random.Range(minRange, maxRange);
						<>7__wrap2 = Player.PlayerList.GetEnumerator();
						<>1__state = -3;
						goto IL_033e;
					}
					case 2:
						{
							<>1__state = -3;
							if (!NACops.registered)
							{
								result = false;
								<>m__Finally1();
								break;
							}
							if (((NPC)<officer>5__5).Awareness.VisionCone.IsPlayerVisible(<player>5__4))
							{
								<player>5__4.CrimeData.SetPursuitLevel((EPursuitLevel)4);
								<officer>5__5.BeginFootPursuit(<player>5__4.PlayerCode);
							}
							if (BaseUtility.GUIDInUse.Contains(((NPC)<officer>5__5).BakedGUID))
							{
								BaseUtility.GUIDInUse.Remove(((NPC)<officer>5__5).BakedGUID);
							}
							<officer>5__5 = null;
							<player>5__4 = null;
							goto IL_033e;
						}
						IL_00cf:
						DebugModule.Log("Nearby Lethal Cop Evaluate", "RunNearbyLethalCops");
						currentAwait = randWaits[Random.Range(0, randWaits.Count)];
						<>2__current = currentAwait;
						<>1__state = 1;
						result = true;
						break;
						IL_033e:
						while (true)
						{
							if (<>7__wrap2.MoveNext())
							{
								<player>5__4 = <>7__wrap2.Current;
								<player>5__4.CrimeData.CheckNearestOfficer();
								<officer>5__5 = <player>5__4.CrimeData.NearestOfficer;
								if (!((Object)(object)<officer>5__5 == (Object)null) && BaseUtility.CanProceed(<officer>5__5, <player>5__4, <minDistance>5__2))
								{
									BaseUtility.GUIDInUse.Add(((NPC)<officer>5__5).BakedGUID);
									((NPC)<officer>5__5).Movement.FacePoint(((Component)Player.Local).transform.position, 0.4f);
									<>2__current = NACops.Wait05;
									<>1__state = 2;
									result = true;
									goto end_IL_0008;
								}
								continue;
							}
							<>m__Finally1();
							<>7__wrap2 = default(List<Player>.Enumerator);
							break;
						}
						goto IL_00cf;
						end_IL_0008:
						break;
					}
				}
				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();
			}
		}

		private static float minWait;

		private static float maxWait;

		private static float minRange;

		private static float maxRange;

		private static List<WaitForSeconds> randWaits;

		private static WaitForSeconds currentAwait;

		[IteratorStateMachine(typeof(<RunNearbyLethalCops>d__6))]
		public static IEnumerator RunNearbyLethalCops()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RunNearbyLethalCops>d__6(0);
		}
	}
	public static class NearbyCrazyCops
	{
		[CompilerGenerated]
		private sealed class <GreedyBodySearchFind>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer officer;

			public Player player;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: 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_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((VOEmitter)officer.ChatterVO).Play((EVOLineType)13);
					((NPC)officer).Movement.FacePoint(((Component)player).transform.position, 0.4f);
					<>2__current = NACops.Wait05;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					if (((NPC)officer).Awareness.VisionCone.IsPlayerVisible(player) && !player.CrimeData.BodySearchPending)
					{
						officer.BeginBodySearch(player.PlayerCode);
						if (Random.Range(0f, 1f) > 0.8f)
						{
							NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(2, player)));
						}
						if (BaseUtility.GUIDInUse.Contains(((NPC)officer).BakedGUID))
						{
							BaseUtility.GUIDInUse.Remove(((NPC)officer).BakedGUID);
						}
						return false;
					}
					Vector3 val = default(Vector3);
					((NPC)officer).Movement.GetClosestReachablePoint(player.CenterPointTransform.position, ref val);
					if (val != Vector3.zero && ((NPC)officer).Movement.CanMove() && ((NPC)officer).Movement.CanGetTo(val, 1f))
					{
						((NPC)officer).Movement.SetDestination(val);
					}
					if (BaseUtility.GUIDInUse.Contains(((NPC)officer).BakedGUID))
					{
						BaseUtility.GUIDInUse.Remove(((NPC)officer).BakedGUID);
					}
					<>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 <RunNearbyCrazyCops>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 <RunNearbyCrazyCops>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Expected O, but got Unknown
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Expected O, but got Unknown
				//IL_0167: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					DebugModule.Log("Nearby Crazy Cop Evaluate", "RunNearbyCrazyCops");
					Object.FindObjectsOfType<Player>(true);
					var (num2, num3) = ThresholdUtils.Evaluate(NACops.thresholdConfig.NearbyCrazyFrequency, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
					if (num2 != minWait || num3 != maxWait)
					{
						randWaits.Clear();
						for (int i = 0; i < 3; i++)
						{
							randWaits.Add(new WaitForSeconds(Random.Range(num2, num3)));
						}
					}
					(float min, float max) tuple2 = ThresholdUtils.Evaluate(NACops.thresholdConfig.NearbyCrazyRange, (int)NetworkSingleton<MoneyManager>.Instance.LifetimeEarnings);
					minRange = tuple2.min;
					maxRange = tuple2.max;
					float num4 = Random.Range(minRange, maxRange);
					foreach (Player player in Player.PlayerList)
					{
						player.CrimeData.CheckNearestOfficer();
						PoliceOfficer nearestOfficer = player.CrimeData.NearestOfficer;
						if (!((Object)(object)nearestOfficer == (Object)null) && BaseUtility.CanProceed(nearestOfficer, player, num4, ignoreVehicle: true))
						{
							BaseUtility.GUIDInUse.Add(((NPC)nearestOfficer).BakedGUID);
							if (((NPC)nearestOfficer).IsInVehicle && player.IsInVehicle)
							{
								nearestOfficer.VehiclePursuitBehaviour.AssignTarget(player);
								nearestOfficer.VehiclePursuitBehaviour.beginAsSighted = true;
								((Behaviour)nearestOfficer.VehiclePursuitBehaviour).Activate();
							}
							else if (!((NPC)nearestOfficer).IsInVehicle)
							{
								NACops.coros.Add(MelonCoroutines.Start(GreedyBodySearchFind(nearestOfficer, player, num4)));
							}
							break;
						}
					}
				}
				else
				{
					<>1__state = -1;
					if (!NACops.networkManager.IsServer)
					{
						return false;
					}
					DebugModule.Log("Nearby Crazy Cop Enabled", "RunNearbyCrazyCops");
					(float min, float max) tuple3 = ThresholdUtils.Evaluate(NACops.thresholdConfig.NearbyCrazyFrequency, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
					minWait = tuple3.min;
					maxWait = tuple3.max;
					randWaits = new List<WaitForSeconds>
					{
						new WaitForSeconds(Random.Range(minWait, maxWait)),
						new WaitForSeconds(Random.Range(minWait, maxWait)),
						new WaitForSeconds(Random.Range(minWait, maxWait))
					};
				}
				currentAwait = randWaits[Random.Range(0, randWaits.Count)];
				<>2__current = currentAwait;
				<>1__state = 1;
				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();
			}
		}

		private static float minWait;

		private static float maxWait;

		private static float minRange;

		private static float maxRange;

		private static List<WaitForSeconds> randWaits;

		private static WaitForSeconds currentAwait;

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

		[IteratorStateMachine(typeof(<GreedyBodySearchFind>d__7))]
		public static IEnumerator GreedyBodySearchFind(PoliceOfficer officer, Player player, float minDistance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GreedyBodySearchFind>d__7(0)
			{
				officer = officer,
				player = player
			};
		}
	}
	public static class BuildInfo
	{
		public const string Name = "NACopsV1";

		public const string Description = "Crazyyyy cops";

		public const string Author = "XOWithSauce";

		public const string Company = null;

		public const string Version = "2.0.2";

		public const string DownloadLink = null;
	}
	public class NACops : MelonMod
	{
		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
		public static class SaveManager_Save_String_Patch
		{
			public static bool Prefix(SaveManager __instance, string saveFolderPath)
			{
				if (!isSaving)
				{
					isSaving = true;
					lock (heatConfigLock)
					{
						ConfigLoader.Save(new PropertiesHeatSerialized
						{
							loadedPropertyHeats = new List<PropertyHeat>(heatConfig)
						});
					}
				}
				isSaving = false;
				return true;
			}
		}

		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { })]
		public static class SaveManager_Save_Patch
		{
			public static bool Prefix(SaveManager __instance)
			{
				return true;
			}
		}

		[HarmonyPatch(typeof(LoadManager), "ExitToMenu")]
		public static class LoadManager_ExitToMenu_Patch
		{
			public static bool Prefix(LoadManager __instance, SaveInfo autoLoadSave = null, Data mainMenuPopup = null, bool preventLeaveLobby = false)
			{
				ExitPreTask();
				return true;
			}
		}

		[HarmonyPatch(typeof(DeathScreen), "LoadSaveClicked")]
		public static class DeathScreen_LoadSaveClicked_Patch
		{
			public static bool Prefix(DeathScreen __instance)
			{
				ExitPreTask();
				return true;
			}
		}

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

			public static Action <1>__OnDayPassEvaluateRaid;
		}

		[CompilerGenerated]
		private sealed class <AddDayPassRaid>d__34 : 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 <AddDayPassRaid>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				if (!currentConfig.RaidsEnabled)
				{
					return false;
				}
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				instance.onSleepEnd = (Action)Delegate.Combine(instance.onSleepEnd, new Action(RaidPropertyEvent.OnDayPassEvaluateRaid));
				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 <OfficersInit>d__32 : 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 <OfficersInit>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				PoliceOfficer[] array;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					DebugModule.Log("Officers Init", "OfficersInit");
					if (officerConfig.ModAddedOfficersCount != 0)
					{
						<>2__current = MelonCoroutines.Start(OfficerOverrides.ExtendOfficerPool());
						<>1__state = 1;
						return true;
					}
					goto IL_005d;
				case 1:
					<>1__state = -1;
					goto IL_005d;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_005d:
					allActiveOfficers.Clear();
					array = Object.FindObjectsOfType<PoliceOfficer>(true);
					foreach (PoliceOfficer item in array)
					{
						allActiveOfficers.Add(item);
					}
					coros.Add(MelonCoroutines.Start(OfficerOverrides.SetOfficers()));
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <OpenCarryInit>d__33 : 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 <OpenCarryInit>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (!currentConfig.NoOpenCarryWeapons)
					{
						return false;
					}
					PlayerSingleton<PlayerInventory>.instance.onEquippedSlotChanged = (Action<int>)Delegate.Combine(PlayerSingleton<PlayerInventory>.instance.onEquippedSlotChanged, new Action<int>(NoticeOpenCarry.OnSlotChanged));
					UnityEvent onArrested = Player.Local.onArrested;
					object obj = <>O.<0>__OnPlayerArrested;
					if (obj == null)
					{
						UnityAction val = NoticeOpenCarry.OnPlayerArrested;
						<>O.<0>__OnPlayerArrested = val;
						obj = (object)val;
					}
					onArrested.AddListener((UnityAction)obj);
					NoticeOpenCarry.SetWeaponsLegalStatus();
					DebugModule.Log("Enabled No Open Carry Weapons", "OpenCarryInit");
					<>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 <RunCoros>d__36 : 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 <RunCoros>d__36(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;
					DebugModule.Log("Coros begin", "RunCoros");
					if (currentConfig.NearbyCrazyCops)
					{
						coros.Add(MelonCoroutines.Start(NearbyCrazyCops.RunNearbyCrazyCops()));
					}
					if (currentConfig.LethalCops)
					{
						coros.Add(MelonCoroutines.Start(LethalCops.RunNearbyLethalCops()));
					}
					if (currentConfig.RacistCops)
					{
						coros.Add(MelonCoroutines.Start(RacistOfficers.EvaluateOfficersVision()));
					}
					if (currentConfig.PrivateInvestigator)
					{
						coros.Add(MelonCoroutines.Start(PrivateInvestigator.RunInvestigator()));
					}
					<>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 <Setup>d__31 : 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 <Setup>d__31(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => Singleton<LoadManager>.Instance.IsGameLoaded));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = Wait5;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					currentConfig = ConfigLoader.LoadModConfig();
					officerConfig = ConfigLoader.LoadOfficerConfig();
					heatConfig = ConfigLoader.LoadPropertyHeats().loadedPropertyHeats;
					thresholdConfig = ConfigLoader.LoadFrequencyConfig();
					raidConfig = ConfigLoader.LoadRaidConfig();
					networkManager = Object.FindObjectOfType<NetworkManager>(true);
					RaidPropertyEvent.SetRaidSprite();
					BaseUtility.SetPoliceNPC();
					<>2__current = MelonCoroutines.Start(AddDayPassRaid());
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = MelonCoroutines.Start(StationInit());
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = MelonCoroutines.Start(OfficersInit());
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					coros.Add(MelonCoroutines.Start(OpenCarryInit()));
					coros.Add(MelonCoroutines.Start(RunCoros()));
					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 <StationInit>d__35 : 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 <StationInit>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					DebugModule.Log("Generating Law settings", "StationInit");
					DebugModule.Log("Apply Custom to All Days", "StationInit");
					foreach (KeyValuePair<string, LawActivitySettings> item in new Dictionary<string, LawActivitySettings>
					{
						{
							"mon",
							Singleton<LawController>.Instance.MondaySettings
						},
						{
							"tue",
							Singleton<LawController>.Instance.TuesdaySettings
						},
						{
							"wed",
							Singleton<LawController>.Instance.WednesdaySettings
						},
						{
							"thu",
							Singleton<LawController>.Instance.ThursdaySettings
						},
						{
							"fri",
							Singleton<LawController>.Instance.FridaySettings
						},
						{
							"sat",
							Singleton<LawController>.Instance.SaturdaySettings
						},
						{
							"sun",
							Singleton<LawController>.Instance.SundaySettings
						}
					})
					{
						DebugModule.Log("Generating patrols, vehicle patrols and sentries for day: " + item.Key, "StationInit");
						_ = item.Key;
						LawActivitySettings val = new LawActivitySettings();
						val.Curfews = item.Value.Curfews;
						val.Checkpoints = item.Value.Checkpoints;
						if (currentConfig.ExtraOfficerPatrols)
						{
							DebugModule.Log("Gen patrol", "StationInit");
							val.Patrols = FootPatrolGenerator.GeneratePatrol(item.Value, item.Key);
						}
						else
						{
							val.Patrols = item.Value.Patrols;
						}
						if (currentConfig.ExtraVehiclePatrols)
						{
							DebugModule.Log("Gen vehicle patrol", "StationInit");
							val.VehiclePatrols = VehiclePatrolGenerator.GenerateVehiclePatrol(item.Value, item.Key);
						}
						else
						{
							val.VehiclePatrols = item.Value.VehiclePatrols;
						}
						if (currentConfig.ExtraOfficerSentries)
						{
							DebugModule.Log("Gen sentries", "StationInit");
							val.Sentries = SentryGenerator.GenerateSentry(item.Value, item.Key);
						}
						else
						{
							val.Sentries = item.Value.Sentries;
						}
						generatedLawSettings.Add(val);
						switch (item.Key)
						{
						case "mon":
							Singleton<LawController>.Instance.MondaySettings = val;
							break;
						case "tue":
							Singleton<LawController>.Instance.TuesdaySettings = val;
							break;
						case "wed":
							Singleton<LawController>.Instance.WednesdaySettings = val;
							break;
						case "thu":
							Singleton<LawController>.Instance.ThursdaySettings = val;
							break;
						case "fri":
							Singleton<LawController>.Instance.FridaySettings = val;
							break;
						case "sat":
							Singleton<LawController>.Instance.SaturdaySettings = val;
							break;
						case "sun":
							Singleton<LawController>.Instance.SundaySettings = val;
							break;
						}
					}
					<>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();
			}
		}

		public static ConfigLoader.ModConfig currentConfig;

		public static ConfigLoader.NAOfficerConfig officerConfig;

		public static ThresholdMappings thresholdConfig;

		public static ConfigLoader.RaidConfig raidConfig;

		public static object heatConfigLock = new object();

		public static List<PropertyHeat> heatConfig;

		public static bool isSaving = false;

		public static List<object> coros = new List<object>();

		public static readonly HashSet<PoliceOfficer> allActiveOfficers = new HashSet<PoliceOfficer>();

		public static HashSet<PoliceOfficer> currentDrugApprehender = new HashSet<PoliceOfficer>();

		public static HashSet<PoliceOfficer> currentSummoned = new HashSet<PoliceOfficer>();

		public static int currentPICount = 0;

		public static bool registered = false;

		public static bool lastSaveLoad = false;

		public static bool firstTimeLoad = false;

		public static NetworkObject policeBase;

		public static NetworkManager networkManager;

		public static List<LawActivitySettings> generatedLawSettings = new List<LawActivitySettings>();

		public static WaitForSeconds Wait01 = new WaitForSeconds(0.1f);

		public static WaitForSeconds Wait05 = new WaitForSeconds(0.5f);

		public static WaitForSeconds Wait1 = new WaitForSeconds(1f);

		public static WaitForSeconds Wait2 = new WaitForSeconds(2f);

		public static WaitForSeconds Wait5 = new WaitForSeconds(5f);

		public static WaitForSeconds Wait30 = new WaitForSeconds(30f);

		public static NACops Instance { get; private set; }

		public override void OnInitializeMelon()
		{
			((MelonBase)this).OnInitializeMelon();
			Instance = this;
			MelonLogger.Msg("NACops Mod Loaded");
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if (buildIndex == 1 && (Object)(object)Singleton<LoadManager>.Instance != (Object)null && !registered && !firstTimeLoad)
			{
				firstTimeLoad = true;
				Singleton<LoadManager>.Instance.onLoadComplete.AddListener(new UnityAction(OnLoadCompleteCb));
			}
			if (buildIndex != 1 && registered)
			{
				ExitPreTask();
			}
		}

		private void OnLoadCompleteCb()
		{
			if (!registered)
			{
				registered = true;
				coros.Add(MelonCoroutines.Start(Setup()));
			}
		}

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

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

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

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

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

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

		private static void ExitPreTask()
		{
			registered = false;
			foreach (object coro in coros)
			{
				if (coro != null)
				{
					MelonCoroutines.Stop(coro);
				}
			}
			allActiveOfficers.Clear();
			coros.Clear();
			currentSummoned.Clear();
			currentDrugApprehender.Clear();
			Player_ConsumeProduct_Patch.evaluating = false;
			OfficerOverrides.generatedOfficerPool.Clear();
			generatedLawSettings.Clear();
			FootPatrolGenerator.generatedPatrolInstances.Clear();
			FootPatrolGenerator.serPatrols = null;
			VehiclePatrolGenerator.generatedVehiclePatrolInstances.Clear();
			VehiclePatrolGenerator.serVehiclePatrols = null;
			SentryGenerator.generatedSentryInstances.Clear();
			SentryGenerator.serSentries = null;
			networkManager = null;
			currentPICount = 0;
			NoticeOpenCarry.HasSetBrandishing = false;
			NoticeOpenCarry.IsCheckingSlot = false;
			PrivateInvestigator.investigatorObjectIDs.Clear();
			if (RuntimeImpostor.createdTextures.Count > 0)
			{
				foreach (Texture2D value in RuntimeImpostor.createdTextures.Values)
				{
					if ((Object)(object)value != (Object)null)
					{
						Object.Destroy((Object)(object)value);
					}
				}
				RuntimeImpostor.createdTextures.Clear();
			}
			heatConfig.Clear();
			RaidPropertyEvent.ResetRaidEvent();
		}
	}
	public static class NoticeOpenCarry
	{
		public static readonly List<string> weaponIDs = new List<string> { "baseballbat", "fryingpan", "machete", "revolver", "goldenm1911", "m1911", "pumpshotgun" };

		public static bool HasSetBrandishing = false;

		public static bool IsCheckingSlot = false;

		public static void CheckSlotItem()
		{
			DebugModule.Log("Checking slot: " + PlayerSingleton<PlayerInventory>.Instance.EquippedSlotIndex, "CheckSlotItem");
			int equippedSlotIndex = PlayerSingleton<PlayerInventory>.Instance.EquippedSlotIndex;
			if (equippedSlotIndex >= 0 && equippedSlotIndex < 8)
			{
				ItemInstance itemInstance = Player.Local.Inventory[equippedSlotIndex].ItemInstance;
				if (itemInstance != null)
				{
					if (weaponIDs.Contains(((BaseItemInstance)itemInstance).ID))
					{
						SetNoticable(enabled: true);
					}
					else
					{
						SetNoticable(enabled: false);
					}
				}
				else
				{
					SetNoticable(enabled: false);
				}
			}
			else
			{
				SetNoticable(enabled: false);
			}
			IsCheckingSlot = false;
			DebugModule.Log("Checked slot", "CheckSlotItem");
		}

		public static void OnSlotChanged(int _)
		{
			if (!IsCheckingSlot)
			{
				IsCheckingSlot = true;
				CheckSlotItem();
			}
		}

		public static void OnPlayerArrested()
		{
			((EntityVisibility)Player.Local.VisualState).RemoveState("Brandishing", 0f);
		}

		public static void SetNoticable(bool enabled)
		{
			if (enabled && !HasSetBrandishing)
			{
				HasSetBrandishing = true;
				((EntityVisibility)Player.Local.VisualState).ApplyState("Brandishing", (EVisualState)9, 0f);
				DebugModule.Log("Player Brandishing", "SetNoticable");
			}
			else if (!enabled && HasSetBrandishing)
			{
				HasSetBrandishing = false;
				DebugModule.Log("RemoveState Brandishing", "SetNoticable");
				((EntityVisibility)Player.Local.VisualState).RemoveState("Brandishing", 0f);
			}
		}

		public static void SetWeaponsLegalStatus()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Func<string, ItemDefinition> func = Registry.GetItem;
			foreach (string weaponID in weaponIDs)
			{
				((BaseItemDefinition)func(weaponID)).legalStatus = (ELegalStatus)4;
			}
		}
	}
	[HarmonyPatch(typeof(PursuitBehaviour), "UpdateArrest")]
	public static class PursuitBehaviour_UpdateArrest_Patch
	{
		public static bool Prefix(PursuitBehaviour __instance, float tick)
		{
			//IL_002e: 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)
			if (!NACops.officerConfig.OverrideArresting)
			{
				return true;
			}
			if ((Object)(object)__instance.TargetPlayer == (Object)null)
			{
				return false;
			}
			if (!__instance.arrestingEnabled)
			{
				return false;
			}
			if (Vector3.Distance(((Behaviour)__instance).Npc.CenterPoint, __instance.TargetPlayer.Avatar.CenterPoint) < NACops.officerConfig.ArrestRange && ((CombatBehaviour)__instance).IsTargetRecentlyVisible)
			{
				__instance.timeWithinArrestRange += tick;
				if (__instance.timeWithinArrestRange > 0.5f)
				{
					__instance.wasInArrestCircleLastFrame = true;
				}
			}
			else
			{
				if (__instance.wasInArrestCircleLastFrame)
				{
					__instance.leaveArrestCircleCount++;
					__instance.wasInArrestCircleLastFrame = false;
				}
				__instance.timeWithinArrestRange = Mathf.Clamp(__instance.timeWithinArrestRange - tick, 0f, float.MaxValue);
			}
			if (((NetworkBehaviour)__instance.TargetPlayer).IsOwner && __instance.timeWithinArrestRange / NACops.officerConfig.ArrestTime > __instance.TargetPlayer.CrimeData.CurrentArrestProgress)
			{
				__instance.TargetPlayer.CrimeData.SetArrestProgress(__instance.timeWithinArrestRange / NACops.officerConfig.ArrestTime);
			}
			return false;
		}
	}
	public static class OfficerOverrides
	{
		[CompilerGenerated]
		private sealed class <ExtendOfficerPool>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 <ExtendOfficerPool>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;
					PoliceStation val = PoliceStation.PoliceStations.FirstOrDefault();
					if (((NPCEnterableBuilding)val).Doors.Length == 0)
					{
						DebugModule.Log("Station doors is empty, failed to extend officer pool", "ExtendOfficerPool");
						return false;
					}
					for (int i = 0; i < val.OfficerPool.Count; i++)
					{
						generatedOfficerPool.Add(val.OfficerPool[i]);
					}
					for (int j = 0; j < NACops.officerConfig.ModAddedOfficersCount; j++)
					{
						PoliceOfficer val2 = SpawnOfficerRuntime(j);
						((NPCEnterableBuilding)val).NPCEnteredBuilding((NPC)(object)val2, ((NPCEnterableBuilding)val).Doors[0]);
						generatedOfficerPool.Add(val2);
						PoliceOfficer.Officers.Add(val2);
					}
					val.OfficerPool = generatedOfficerPool;
					<>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 <SetOfficers>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private HashSet<PoliceOfficer>.Enumerator <>7__wrap1;

			private PoliceOfficer <officer>5__3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						foreach (PoliceOfficer allActiveOfficer in NACops.allActiveOfficers)
						{
							if ((Object)(object)allActiveOfficer.belt != (Object)null)
							{
								continue;
							}
							for (int i = 0; i < ((NPC)allActiveOfficer).Avatar.appliedAccessories.Length; i++)
							{
								if (!((Object)(object)((NPC)allActiveOfficer).Avatar.appliedAccessories[i] == (Object)null) && ((NPC)allActiveOfficer).Avatar.appliedAccessories[i].AssetPath == "Avatar/Accessories/Waist/PoliceBelt/PoliceBelt")
								{
									PoliceBelt component = ((Component)((NPC)allActiveOfficer).Avatar.appliedAccessories[i]).gameObject.GetComponent<PoliceBelt>();
									if ((Object)(object)component != (Object)null)
									{
										allActiveOfficer.belt = component;
									}
									else
									{
										DebugModule.Log("Belt component is null and cant assign", "SetOfficers");
									}
									break;
								}
							}
						}
						DebugModule.Log("Set officers foreach stats for " + NACops.allActiveOfficers.Count, "SetOfficers");
						<>7__wrap1 = NACops.allActiveOfficers.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<officer>5__3.Leniency = 0.1f;
						<officer>5__3.Suspicion = 1f;
						AvatarUtility.SetRandomAvatar(<officer>5__3);
						if (NACops.officerConfig.CanEnterBuildings)
						{
							((NPC)<officer>5__3).Movement.Agent.areaMask = 57;
						}
						if (NACops.officerConfig.OverrideBodySearch)
						{
							<officer>5__3.BodySearchDuration = NACops.officerConfig.BodySearchDuration;
							<officer>5__3.BodySearchChance = NACops.officerConfig.BodySearchChance;
						}
						if (NACops.officerConfig.OverrideMovement)
						{
							((NPC)<officer>5__3).Movement.MoveSpeedMultiplier = NACops.officerConfig.MovementSpeedMultiplier;
						}
						if (NACops.officerConfig.OverrideCombatBeh)
						{
							((NPC)<officer>5__3).Behaviour.CombatBehaviour.GiveUpRange = NACops.officerConfig.CombatGiveUpRange;
							((NPC)<officer>5__3).Behaviour.CombatBehaviour.DefaultSearchTime = NACops.officerConfig.CombatSearchTime;
							((NPC)<officer>5__3).Behaviour.CombatBehaviour.DefaultMovementSpeed = NACops.officerConfig.CombatMoveSpeed;
							((NPC)<officer>5__3).Behaviour.CombatBehaviour.GiveUpAfterSuccessfulHits = NACops.officerConfig.CombatEndAfterHits;
						}
						if (NACops.officerConfig.OverrideMaxHealth)
						{
							((NPC)<officer>5__3).Health.MaxHealth = NACops.officerConfig.OfficerMaxHealth;
							((NPC)<officer>5__3).Health.Health = NACops.officerConfig.OfficerMaxHealth;
							if (((NPC)<officer>5__3).Health.IsDead || ((NPC)<officer>5__3).Health.IsKnockedOut)
							{
								((NPC)<officer>5__3).Health.Revive();
							}
						}
						if (NACops.officerConfig.OverrideWeapon)
						{
							AvatarRangedWeapon val = null;
							AvatarEquippable gunPrefab = <officer>5__3.GunPrefab;
							val = (AvatarRangedWeapon)(object)((gunPrefab is AvatarRangedWeapon) ? gunPrefab : null);
							if ((Object)(object)val != (Object)null)
							{
								val.CanShootWhileMoving = true;
								val.MagazineSize = NACops.officerConfig.WeaponMagSize;
								val.MaxFireRate = NACops.officerConfig.WeaponFireRate;
								((AvatarWeapon)val).MaxUseRange = NACops.officerConfig.WeaponMaxRange;
								val.ReloadTime = NACops.officerConfig.WeaponReloadTime;
								val.RaiseTime = NACops.officerConfig.WeaponRaiseTime;
								val.HitChance_MaxRange = NACops.officerConfig.WeaponHitChanceMax;
								val.HitChance_MinRange = NACops.officerConfig.WeaponHitChanceMin;
								((AvatarWeapon)val).CooldownDuration = NACops.officerConfig.WeaponFireRate;
								val.Damage = NACops.officerConfig.WeaponDamage;
							}
							if ((Object)(object)val != (Object)null && (Object)(object)((NPC)<officer>5__3).Behaviour.CombatBehaviour.DefaultWeapon == (Object)null)
							{
								((NPC)<officer>5__3).Behaviour.CombatBehaviour.DefaultWeapon = (AvatarWeapon)(object)val;
							}
							DebugModule.Log("  Overridden weapon", "SetOfficers");
						}
						<officer>5__3 = null;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						<officer>5__3 = <>7__wrap1.Current;
						<>2__current = NACops.Wait01;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = default(HashSet<PoliceOfficer>.Enumerator);
					DebugModule.Log("Officer properties complete", "SetOfficers");
					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__wrap1).Dispose();
			}

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

		public static List<PoliceOfficer> generatedOfficerPool = new List<PoliceOfficer>();

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

		public static PoliceOfficer SpawnOfficerRuntime(int i, bool autoDeactivate = true)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			NetworkObject val = Object.Instantiate<NetworkObject>(NACops.policeBase);
			PoliceOfficer component = ((Component)val).gameObject.GetComponent<PoliceOfficer>();
			component.AutoDeactivate = autoDeactivate;
			NPC component2 = ((Component)val).gameObject.GetComponent<NPC>();
			component2.ID = $"NACops_RuntimeOfficer_{i}";
			component2.FirstName = "Officer";
			component2.LastName = "";
			((Component)component2).transform.parent = NetworkSingleton<NPCManager>.Instance.NPCContainer;
			NPCManager.NPCRegistry.Add(component2);
			NACops.networkManager.ServerManager.Spawn(val, (NetworkConnection)null, default(Scene));
			((Component)val).gameObject.SetActive(true);
			((Object)val).name = $"NACops_RuntimeOfficer_{i}";
			return component;
		}

		public static PoliceOfficer SpawnOfficerRuntime(bool autoDeactivate = true)
		{
			return SpawnOfficerRuntime(Random.Range(1000, 6000), autoDeactivate);
		}

		[IteratorStateMachine(typeof(<SetOfficers>d__4))]
		public static IEnumerator SetOfficers()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetOfficers>d__4(0);
		}
	}
	public static class RacistOfficers
	{
		[CompilerGenerated]
		private sealed class <EvaluateOfficersVision>d__0 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private List<Player> <blackPlayers>5__2;

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

			private Player <player>5__4;

			private HashSet<PoliceOfficer>.Enumerator <>7__wrap4;

			private PoliceOfficer <officer>5__6;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || (uint)(num - 2) <= 1u)
				{
					try
					{
						if (num == -4 || num == 2)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<blackPlayers>5__2 = null;
				<>7__wrap2 = default(List<Player>.Enumerator);
				<player>5__4 = null;
				<>7__wrap4 = default(HashSet<PoliceOfficer>.Enumerator);
				<officer>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02aa: Invalid comparison between Unknown and I4
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						if (!NACops.networkManager.IsServer)
						{
							return false;
						}
						DebugModule.Log("Racist officers enabled", "EvaluateOfficersVision");
						<blackPlayers>5__2 = new List<Player>();
						foreach (Player player in Player.PlayerList)
						{
							if (!player.Avatar.IsWhite())
							{
								<blackPlayers>5__2.Add(player);
							}
						}
						if (<blackPlayers>5__2.Count == 0)
						{
							return false;
						}
						goto IL_03ec;
					case 1:
						<>1__state = -1;
						<>7__wrap2 = <blackPlayers>5__2.GetEnumerator();
						<>1__state = -3;
						goto IL_03ca;
					case 2:
						<>1__state = -4;
						if (!Object.op_Implicit((Object)(object)((NPC)<officer>5__6).Behaviour.activeBehaviour) || (!((Object)(object)((NPC)<officer>5__6).Behaviour.activeBehaviour == (Object)(object)<officer>5__6.PursuitBehaviour) && !((Object)(object)((NPC)<officer>5__6).Behaviour.activeBehaviour == (Object)(object)<officer>5__6.VehiclePursuitBehaviour)))
						{
							if (Vector3.Distance(((NPC)<officer>5__6).CenterPoint, <player>5__4.CenterPointTransform.position) < 80f)
							{
								if (<officer>5__6.PursuitBehaviour.arrestingEnabled)
								{
									NACops.coros.Add(MelonCoroutines.Start(TempDisableArrest(<officer>5__6)));
								}
								if ((int)<player>5__4.CrimeData.CurrentPursuitLevel != 4)
								{
									<player>5__4.CrimeData.SetPursuitLevel((EPursuitLevel)4);
								}
								if (((NPC)<officer>5__6).isInBuilding)
								{
									((NPC)<officer>5__6).ExitBuilding((NPCEnterableBuilding)(object)PoliceStation.PoliceStations[0]);
								}
								if (!((NPC)<officer>5__6).IsInVehicle && (Object)(object)((NPC)<officer>5__6).Behaviour.activeBehaviour != (Object)(object)<officer>5__6.PursuitBehaviour)
								{
									<officer>5__6.BeginFootPursuit(<player>5__4.PlayerCode);
								}
								else if (((NPC)<officer>5__6).IsInVehicle && (Object)(object)((NPC)<officer>5__6).Behaviour.activeBehaviour != (Object)(object)<officer>5__6.VehiclePursuitBehaviour)
								{
									<officer>5__6.VehiclePursuitBehaviour.AssignTarget(<player>5__4);
									<officer>5__6.VehiclePursuitBehaviour.StartPursuit();
								}
							}
							<officer>5__6 = null;
						}
						goto IL_0383;
					case 3:
						<>1__state = -3;
						<player>5__4 = null;
						goto IL_03ca;
					case 4:
						{
							<>1__state = -1;
							return false;
						}
						IL_03ca:
						while (<>7__wrap2.MoveNext())
						{
							<player>5__4 = <>7__wrap2.Current;
							if ((Object)(object)<player>5__4.CurrentProperty != (Object)null)
							{
								continue;
							}
							bool flag = false;
							foreach (PoliceOfficer allActiveOfficer in NACops.allActiveOfficers)
							{
								if (!((NPC)allActiveOfficer).Health.IsDead && !((NPC)allActiveOfficer).Health.IsKnockedOut && ((NPC)allActiveOfficer).Awareness.VisionCone.IsPlayerVisible(<player>5__4))
								{
									flag = true;
									break;
								}
							}
							if (!flag)
							{
								continue;
							}
							goto IL_0193;
						}
						<>m__Finally1();
						<>7__wrap2 = default(List<Player>.Enumerator);
						goto IL_03ec;
						IL_0383:
						if (<>7__wrap4.MoveNext())
						{
							<officer>5__6 = <>7__wrap4.Current;
							<>2__current = NACops.Wait05;
							<>1__state = 2;
							return true;
						}
						<>m__Finally2();
						<>7__wrap4 = default(HashSet<PoliceOfficer>.Enumerator);
						<>2__current = NACops.Wait30;
						<>1__state = 3;
						return true;
						IL_03ec:
						if (NACops.registered)
						{
							<>2__current = NACops.Wait2;
							<>1__state = 1;
							return true;
						}
						<>2__current = null;
						<>1__state = 4;
						return true;
						IL_0193:
						<>7__wrap4 = NACops.allActiveOfficers.GetEnumerator();
						<>1__state = -4;
						goto IL_0383;
					}
				}
				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__wrap2).Dispose();
			}

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

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

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

			private object <>2__current;

			public PoliceOfficer offc;

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

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

			[DebuggerHidden]
			public <TempDisableArrest>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 = NACops.Wait30;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					offc.PursuitBehaviour.arrestingEnabled = true;
					<>2__current = false;
					<>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();
			}
		}

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

		[IteratorStateMachine(typeof(<TempDisableArrest>d__1))]
		public static IEnumerator TempDisableArrest(PoliceOfficer offc)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TempDisableArrest>d__1(0)
			{
				offc = offc
			};
		}
	}
	public static class PrivateInvestigator
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0
		{
			public UnityAction afterAction;

			public PoliceOfficer offc;
		}

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

			private object <>2__current;

			private <>c__DisplayClass12_0 <>8__1;

			private Player <randomPlayer>5__2;

			private float <elapsed>5__3;

			private int <proximityDelta>5__4;

			private int <sightedAmount>5__5;

			private float <maxWarpCd>5__6;

			private float <lastWarp>5__7;

			private Dictionary<string, int> <sightedProperties>5__8;

			private float <distance>5__9;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Expected O, but got Unknown
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Expected O, but got Unknown
				//IL_0357: Unknown result type (might be due to invalid IL or missing references)
				//IL_0367: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0446: Unknown result type (might be due to invalid IL or missing references)
				//IL_056e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a5a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a5d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a6f: Expected I4, but got Unknown
				//IL_0737: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0658: Unknown result type (might be due to invalid IL or missing references)
				//IL_0665: Unknown result type (might be due to invalid IL or missing references)
				//IL_0671: Unknown result type (might be due to invalid IL or missing references)
				//IL_067e: Unknown result type (might be due to invalid IL or missing references)
				//IL_064c: Unknown result type (might be due to invalid IL or missing references)
				//IL_08da: Unknown result type (might be due to invalid IL or missing references)
				//IL_08df: Unknown result type (might be due to invalid IL or missing references)
				//IL_08e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_08f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0900: Unknown result type (might be due to invalid IL or missing references)
				//IL_0902: Unknown result type (might be due to invalid IL or missing references)
				//IL_0911: Unknown result type (might be due to invalid IL or missing references)
				//IL_091e: Unknown result type (might be due to invalid IL or missing references)
				//IL_092a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0937: Unknown result type (might be due to invalid IL or missing references)
				//IL_0710: Unknown result type (might be due to invalid IL or missing references)
				//IL_09bd: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass12_0();
					<randomPlayer>5__2 = Player.GetRandomPlayer(true, true);
					NACops.currentPICount++;
					<>8__1.offc = OfficerOverrides.SpawnOfficerRuntime(autoDeactivate: false);
					((NPC)<>8__1.offc).Behaviour.ScheduleManager.DisableSchedule();
					((NPC)<>8__1.offc).Movement.PauseMovement();
					NACops.currentSummoned.Add(<>8__1.offc);
					investigatorObjectIDs.Add(((Object)((Component)((Component)<>8__1.offc).transform.root).gameObject).GetInstanceID());
					((NPC)<>8__1.offc).Movement.SpeedController.AddSpeedControl(new SpeedControl("combat", 5, 0.55f));
					<>8__1.offc.ChatterEnabled = false;
					<>2__current = AvatarUtility.PIAvatar(<>8__1.offc);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = BaseUtility.AttemptWarp(<>8__1.offc, <randomPlayer>5__2.CenterPointTransform);
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					((NPC)<>8__1.offc).Movement.ResumeMovement();
					<elapsed>5__3 = 0f;
					<proximityDelta>5__4 = 0;
					<sightedAmount>5__5 = 0;
					<maxWarpCd>5__6 = 15f;
					<lastWarp>5__7 = 0f;
					bool flag = false;
					<>8__1.afterAction = null;
					<>8__1.afterAction = new UnityAction(AfterInvestigation);
					((Behaviour)<>8__1.offc.PursuitBehaviour).onBegin.AddListener(<>8__1.afterAction);
					((Behaviour)((NPC)<>8__1.offc).Awareness).enabled = false;
					ISightable val5 = (ISightable)(object)<randomPlayer>5__2;
					Dictionary<EVisualState, StateContainer> dictionary = new Dictionary<EVisualState, StateContainer>();
					if (val5 == null)
					{
						DebugModule.Log("Warning sightable is null", "HandlePIMonitor");
					}
					else if (((NPC)<>8__1.offc).Awareness.VisionCone.stateSettings.ContainsKey(val5))
					{
						foreach (KeyValuePair<EVisualState, StateContainer> item in ((NPC)<>8__1.offc).Awareness.VisionCone.stateSettings[val5])
						{
							if (!PIdisabledVisualStates.Contains(item.Key))
							{
								dictionary.Add(item.Key, item.Value);
							}
						}
					}
					if (dictionary.Count == 0)
					{
						DebugModule.Log("Something failed while applying visual state modification", "HandlePIMonitor");
					}
					else if (val5 != null)
					{
						((NPC)<>8__1.offc).Awareness.VisionCone.stateSettings[val5] = dictionary;
					}
					((Behaviour)((NPC)<>8__1.offc).Awareness).enabled = true;
					<sightedProperties>5__8 = new Dictionary<string, int>();
					goto IL_0322;
				}
				case 3:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					<distance>5__9 = Vector3.Distance(((Component)<>8__1.offc).transform.position, ((Component)<randomPlayer>5__2).transform.position);
					if (((NPC)<>8__1.offc).Movement.CanMove() && !(<elapsed>5__3 >= maxInvestigationTime) && (int)<randomPlayer>5__2.CrimeData.CurrentPursuitLevel == 0)
					{
						<elapsed>5__3 += 5f;
						<lastWarp>5__7 += 5f;
						bool flag;
						if (((Behaviour)((NPC)<>8__1.offc).Awareness.VisionCone).enabled && ((NPC)<>8__1.offc).Awareness.VisionCone.IsPlayerVisible(<randomPlayer>5__2))
						{
							flag = true;
							<sightedAmount>5__5++;
						}
						else
						{
							flag = false;
						}
						if (((NPC)<>8__1.offc).Movement.CanGetTo(((Component)<randomPlayer>5__2).transform.position, 100f) && <distance>5__9 >= 90f && <distance>5__9 < 150f)
						{
							DebugModule.Log("PI Should Warp - dist " + <distance>5__9, "HandlePIMonitor");
							if (!(<lastWarp>5__7 < <maxWarpCd>5__6))
							{
								DebugModule.Log("PI Try Warp - dist " + <distance>5__9, "HandlePIMonitor");
								((NPC)<>8__1.offc).Movement.PauseMovement();
								<>2__current = BaseUtility.AttemptWarp(<>8__1.offc, <randomPlayer>5__2.CenterPointTransform);
								<>1__state = 4;
								return true;
							}
						}
						else if (((NPC)<>8__1.offc).Movement.CanGetTo(((Component)<randomPlayer>5__2).transform.position, 100f) && <distance>5__9 >= 25f && <distance>5__9 < 110f)
						{
							Vector3 val = SampleNearby(<randomPlayer>5__2.CenterPointTransform.position);
							Vector3 val2 = default(Vector3);
							((NPC)<>8__1.offc).Movement.GetClosestReachablePoint(val, ref val2);
							if (!(val2 == Vector3.zero))
							{
								if (<distance>5__9 > 55f)
								{
									DebugModule.Log("PI Traverse - dist " + <distance>5__9, "HandlePIMonitor");
									if (((NPC)<>8__1.offc).Movement.IsPaused)
									{
										((NPC)<>8__1.offc).Movement.ResumeMovement();
									}
									((NPC)<>8__1.offc).Movement.SetDestination(val2);
								}
								else
								{
									float num = Vector3.Distance(val2, <randomPlayer>5__2.CenterPointTransform.position);
									bool flag2 = CanSeeFromPosition(val2, <randomPlayer>5__2.CenterPointTransform.position, num);
									if ((!flag && num < <distance>5__9) || flag2)
									{
										DebugModule.Log($"PI Traversing Better Distance:{!flag && num < <distance>5__9} | Can See:{flag2}", "HandlePIMonitor");
										if (((NPC)<>8__1.offc).Movement.IsPaused)
										{
											((NPC)<>8__1.offc).Movement.ResumeMovement();
										}
										((NPC)<>8__1.offc).Movement.SetDestination(val2);
									}
								}
							}
						}
						else
						{
							if (!((NPC)<>8__1.offc).Movement.CanGetTo(((Component)<randomPlayer>5__2).transform.position, 100f) || !(<distance>5__9 <= 25f))
							{
								DebugModule.Log("PI Exit condition", "HandlePIMonitor");
								goto IL_09d8;
							}
							DebugModule.Log("PI Monitoring", "HandlePIMonitor");
							if ((flag || (Object)(object)<randomPlayer>5__2.CurrentProperty != (Object)null || <distance>5__9 <= 15f) && !((NPC)<>8__1.offc).Movement.IsPaused)
							{
								((NPC)<>8__1.offc).Movement.PauseMovement();
							}
							((NPC)<>8__1.offc).Movement.FacePoint(((Component)<randomPlayer>5__2).transform.position, 0.3f);
							if (Random.Range(0f, 1f) > 0.95f)
							{
								NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(1, <randomPlayer>5__2)));
							}
							<proximityDelta>5__4++;
							if ((Object)(object)<randomPlayer>5__2.CurrentProperty != (Object)null)
							{
								if (<sightedProperties>5__8.ContainsKey(<randomPlayer>5__2.CurrentProperty.PropertyCode))
								{
									<sightedProperties>5__8[<randomPlayer>5__2.CurrentProperty.PropertyCode]++;
								}
								else
								{
									<sightedProperties>5__8.Add(<randomPlayer>5__2.CurrentProperty.PropertyCode, 1);
								}
							}
							if (!flag && ((Object)(object)<randomPlayer>5__2.CurrentProperty == (Object)null || Random.Range(0f, 1f) > 0.8f))
							{
								Vector3 val3 = SampleNearby(<randomPlayer>5__2.CenterPointTransform.position);
								Vector3 val4 = default(Vector3);
								((NPC)<>8__1.offc).Movement.GetClosestReachablePoint(val3, ref val4);
								if (!(val4 == Vector3.zero))
								{
									float num2 = Vector3.Distance(val4, <randomPlayer>5__2.CenterPointTransform.position);
									bool flag3 = CanSeeFromPosition(val4, <randomPlayer>5__2.CenterPointTransform.position, num2);
									if (num2 < <distance>5__9 || flag3)
									{
										DebugModule.Log($"PI Traversing Better Distance:{num2 < <distance>5__9} | Can See:{flag3}", "HandlePIMonitor");
										if (((NPC)<>8__1.offc).Movement.IsPaused)
										{
											((NPC)<>8__1.offc).Movement.ResumeMovement();
										}
										((NPC)<>8__1.offc).Movement.SetDestination(val4);
									}
								}
							}
						}
						goto IL_0322;
					}
					goto IL_09d8;
				case 4:
					<>1__state = -1;
					((NPC)<>8__1.offc).Movement.ResumeMovement();
					DebugModule.Log("PI New dist " + <distance>5__9, "HandlePIMonitor");
					<lastWarp>5__7 = 0f;
					goto IL_0322;
				case 5:
					{
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						DebugModule.Log("Despawning PI", "HandlePIMonitor");
						try
						{
							int instanceID = ((Object)<>8__1.offc).GetInstanceID();
							if (RuntimeImpostor.createdTextures.ContainsKey(instanceID))
							{
								if ((Object)(object)RuntimeImpostor.createdTextures[instanceID] != (Object)null)
								{
									Object.Destroy((Object)(object)RuntimeImpostor.createdTextures[instanceID]);
								}
								RuntimeImpostor.createdTextures.Remove(instanceID);
							}
							if (NACops.currentSummoned.Contains(<>8__1.offc))
							{
								NACops.currentSummoned.Remove(<>8__1.offc);
							}
							NACops.currentPICount--;
							NPC component = ((Component)<>8__1.offc).gameObject.GetComponent<NPC>();
							if ((Object)(object)component != (Object)null && NPCManager.NPCRegistry.Contains(component))
							{
								NPCManager.NPCRegistry.Remove(component);
							}
							if ((Object)(object)component != (Object)null && (Object)(object)((Component)component).gameObject != (Object)null)
							{
								Object.Destroy((Object)(object)((Component)component).gameObject);
							}
						}
						catch (Exception ex)
						{
							MelonLogger.Error((object)ex);
						}
						return false;
					}
					IL_0322:
					<>2__current = NACops.Wait5;
					<>1__state = 3;
					return true;
					IL_09d8:
					if (<sightedProperties>5__8.Count > 0)
					{
						lock (NACops.heatConfigLock)
						{
							foreach (PropertyHeat item2 in NACops.heatConfig)
							{
								if (<sightedProperties>5__8.ContainsKey(item2.propertyCode))
								{
									EPursuitLevel currentPursuitLevel = <randomPlayer>5__2.CrimeData.CurrentPursuitLevel;
									int num3 = <sightedProperties>5__8[item2.propertyCode];
									float num4 = 1f;
									switch (currentPursuitLevel - 2)
									{
									case 0:
										num4 = 1.2f;
										break;
									case 1:
										num4 = 1.45f;
										break;
									case 2:
										num4 = 1.7f;
										break;
									}
									if (num3 >= 12 && <proximityDelta>5__4 > 4 && <sightedAmount>5__5 >= 1 && (Object)(object)<randomPlayer>5__2.CurrentProperty != (Object)null && <randomPlayer>5__2.CurrentProperty.PropertyCode == item2.propertyCode)
									{
										DebugModule.Log("Property heat increased +++", "HandlePIMonitor");
										item2.propertyHeat += Mathf.RoundToInt(Random.Range(6f, 9f) * num4);
									}
									else if (num3 >= 6 && <proximityDelta>5__4 > 2 && <sightedAmount>5__5 >= 1 && (Object)(object)<randomPlayer>5__2.CurrentProperty != (Object)null && <randomPlayer>5__2.CurrentProperty.PropertyCode == item2.propertyCode)
									{
										item2.propertyHeat += Mathf.RoundToInt(Random.Range(4f, 6f) * num4);
										DebugModule.Log("Property heat increased ++", "HandlePIMonitor");
									}
									else if (item2.propertyHeat < 8 && num3 >= 3 && <proximityDelta>5__4 >= 2 && <sightedAmount>5__5 >= 2)
									{
										item2.propertyHeat += Mathf.RoundToInt(Random.Range(2f, 4f) * num4);
										DebugModule.Log("Property heat increased +", "HandlePIMonitor");
									}
									else if (item2.propertyHeat > 5 && <elapsed>5__3 > 60f && <proximityDelta>5__4 > 4)
									{
										item2.propertyHeat += Mathf.RoundToInt(Random.Range(1f, 5f) * num4);
										DebugModule.Log("Property heat decreased", "HandlePIMonitor");
									}
								}
							}
						}
					}
					DebugModule.Log("PI Finished", "HandlePIMonitor");
					DebugModule.Log("Sighted amnt: " + <sightedAmount>5__5, "HandlePIMonitor");
					DebugModule.Log("Proximity delta: " + <proximityDelta>5__4, "HandlePIMonitor");
					DebugModule.Log("Investigation:", "HandlePIMonitor");
					foreach (KeyValuePair<string, int> item3 in <sightedProperties>5__8)
					{
						DebugModule.Log($"{item3.Key} - Investigation delta: {item3.Value}", "HandlePIMonitor");
					}
					AfterInvestigation();
					<>2__current = NACops.Wait30;
					<>1__state = 5;
					return true;
				}
				void AfterInvestigation()
				{
					//IL_011c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0126: Expected O, but got Unknown
					if (((<>c__DisplayClass12_0)this).afterAction != null)
					{
						((Behaviour)((<>c__DisplayClass12_0)this).offc.PursuitBehaviour).onBegin.RemoveListener(((<>c__DisplayClass12_0)this).afterAction);
						((NPC)((<>c__DisplayClass12_0)this).offc).Awareness.SetAwarenessActive(false);
						((<>c__DisplayClass12_0)this).afterAction = null;
						if (!((NPC)((<>c__DisplayClass12_0)this).offc).Health.IsDead && !((NPC)((<>c__DisplayClass12_0)this).offc).Health.IsKnockedOut)
						{
							if (((Behaviour)((NPC)((<>c__DisplayClass12_0)this).offc).Awareness.VisionCone).enabled)
							{
								((NPC)((<>c__DisplayClass12_0)this).offc).Awareness.SetAwarenessActive(false);
							}
							if ((Object)(object)((NPC)((<>c__DisplayClass12_0)this).offc).Behaviour.activeBehaviour != (Object)null && ((Object)(object)((NPC)((<>c__DisplayClass12_0)this).offc).Behaviour.activeBehaviour == (Object)(object)((NPC)((<>c__DisplayClass12_0)this).offc).Behaviour.CombatBehaviour || (Object)(object)((NPC)((<>c__DisplayClass12_0)this).offc).Behaviour.activeBehaviour == (Object)(object)((<>c__DisplayClass12_0)this).offc.PursuitBehaviour))
							{
								((Behaviour)((<>c__DisplayClass12_0)this).offc.PursuitBehaviour).Disable();
							}
							((NPC)((<>c__DisplayClass12_0)this).offc).Movement.SpeedController.AddSpeedControl(new SpeedControl("combat", 5, 0.85f));
							((NPC)((<>c__DisplayClass12_0)this).offc).Movement.SetDestination(((NPCEnterableBuilding)PoliceStation.PoliceStations[0]).Doors[0].AccessPoint);
							if (((NPC)((<>c__DisplayClass12_0)this).offc).Movement.IsPaused)
							{
								((NPC)((<>c__DisplayClass12_0)this).offc).Movement.ResumeMovement();
							}
						}
					}
				}
			}

			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 <RunInvestigator>d__11 : 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 <RunInvestigator>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Expected O, but got Unknown
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Expected O, but got Unknown
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					var (num2, num3) = ThresholdUtils.Evaluate(NACops.thresholdConfig.PIFrequency, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
					if (num2 != minWait || num3 != maxWait)
					{
						randWaits.Clear();
						for (int i = 0; i < 3; i++)
						{
							randWaits.Add(new WaitForSeconds(Random.Range(num2, num3)));
						}
					}
					DebugModule.Log("PI Evaluate", "RunInvestigator");
					EDay currentDay = NetworkSingleton<TimeManager>.Instance.CurrentDay;
					if (!((object)(EDay)(ref currentDay)).ToString().Contains("Saturday") && !((object)(EDay)(ref currentDay)).ToString().Contains("Sunday") && NACops.currentPICount < 1)
					{
						DebugModule.Log("PI Proceed", "RunInvestigator");
						NACops.coros.Add(MelonCoroutines.Start(HandlePIMonitor()));
					}
				}
				else
				{
					<>1__state = -1;
					DebugModule.Log("Private Investigator Enabled", "RunInvestigator");
					playerLayer = LayerMask.NameToLayer("Player");
					obstacleLayerMask = LayerMask.GetMask(new string[3] { "Terrain", "Default", "Vehicle" });
					(float min, float max) tuple2 = ThresholdUtils.Evaluate(NACops.thresholdConfig.PIFrequency, (int)NetworkSingleton<MoneyManager>.Instance.LifetimeEarnings);
					minWait = tuple2.min;
					maxWait = tuple2.max;
					randWaits = new List<WaitForSeconds>
					{
						new WaitForSeconds(Random.Range(minWait, maxWait)),
						new WaitForSeconds(Random.Range(minWait, maxWait)),
						new WaitForSeconds(Random.Range(minWait, maxWait))
					};
				}
				currentAwait = randWaits[Random.Range(0, randWaits.Count)];
				<>2__current = currentAwait;
				<>1__state = 1;
				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 readonly List<string> randomMaleNames = new List<string> { "James", "William", "David", "Richard", "John", "Robert" };

		public static readonly List<string> randomFemaleNames = new List<string> { "Jessica", "Susan", "Linda", "Mary" };

		public static readonly List<EVisualState> PIdisabledVisualStates = new List<EVisualState>
		{
			(EVisualState)9,
			(EVisualState)2,
			(EVisualState)5,
			(EVisualState)7,
			(EVisualState)1
		};

		public static float maxInvestigationTime = 240f;

		private static float minWait;

		private static float maxWait;

		private static List<WaitForSeconds> randWaits;

		private static WaitForSeconds currentAwait;

		private static int playerLayer = -1;

		private static int obstacleLayerMask = -1;

		public static List<int> investigatorObjectIDs = new List<int>();

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

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

		public static bool CanSeeFromPosition(Vector3 pos, Vector3 target, float distance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos + Vector3.up * 1.75f;
			Vector3 val2 = target - val;
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val, ((Vector3)(ref val2)).normalized, ref val3, distance + 2f))
			{
				if ((obstacleLayerMask & (1 << ((Component)((RaycastHit)(ref val3)).collider).gameObject.layer)) != 0)
				{
					DebugModule.Log("New Destination cannot see", "CanSeeFromPosition");
					return false;
				}
				if (((Component)((RaycastHit)(ref val3)).collider).gameObject.layer == playerLayer)
				{
					DebugModule.Log("New Destination can see", "CanSeeFromPosition");
					return true;
				}
			}
			else
			{
				DebugModule.Log("No Raycast hits for sightline check", "CanSeeFromPosition");
			}
			return false;
		}

		public static Vector3 SampleNearby(Vector3 target)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(6f, 24f);
			float num2 = Random.Range(6f, 24f);
			num *= ((Random.Range(0f, 1f) > 0.5f) ? 1f : (-1f));
			num2 *= ((Random.Range(0f, 1f) > 0.5f) ? 1f : (-1f));
			return target + new Vector3(num, 0f, num2);
		}
	}
	[Serializable]
	public class PropertyHeat
	{
		public string propertyCode;

		public int propertyHeat;

		public int daysSinceLastRaid;
	}
	[Serializable]
	public class PropertiesHeatSerialized
	{
		public List<PropertyHeat> loadedPropertyHeats = new List<PropertyHeat>();
	}
	public static class RaidPropertyEvent
	{
		public enum ERaidType
		{
			PropertyRaid,
			BusinessRaid,
			Other
		}

		public enum EOfficerRaidRole
		{
			Undecided,
			DestroyGrowEquipment,
			DestroyLabEquipment,
			SearchContainer
		}

		public enum ERaidDestroyType
		{
			None,
			DestroyPot,
			DestroyShroomBed,
			DestroyDryingRack,
			DestroyLabOven,
			DestroyChemistryStation,
			DestroyCauldron,
			DestroyMixing
		}

		public class RaidOfficer
		{
			public string Name;

			public PoliceOfficer officer;

			public EOfficerRaidRole role;

			public Property targetProperty;

			public BuildableItem currentTargetObj;

			public int destroyedItems;

			public int currentActionIter;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_0
		{
			public List<PropertyHeat> currentHeats;

			public string selectedCode;

			internal bool <WaitDayPass>b__3(PropertyHeat x)
			{
				return x.propertyCode == selectedCode;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_1
		{
			public Property property;

			internal bool <WaitDayPass>b__1(PropertyHeat x)
			{
				return x.propertyCode == property.propertyCode;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_2
		{
			public int i;

			public <>c__DisplayClass31_0 CS$<>8__locals1;

			internal bool <WaitDayPass>b__2(Property x)
			{
				return x.PropertyCode == CS$<>8__locals1.currentHeats[i].propertyCode;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass42_0
		{
			public ITransitEntity entity;

			public Action<WalkResult> walkCallback;

			public bool callbackConsumed;

			public RaidOfficer offc;

			public ERaidDestroyType destroyType;

			public BuildableItem destroyTarget;

			public int targetInstanceID;

			internal void <DestroyEquipment>b__0(Pot t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__1(MushroomBed t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__2(DryingRack t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__3(LabOven t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__4(ChemistryStation t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__5(Cauldron t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__6(MixingStationMk2 t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}

			internal void <DestroyEquipment>b__7(PlaceableStorageEntity t)
			{
				entity = ((Component)t).GetComponent<ITransitEntity>();
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass54_0
		{
			public RaidOfficer offc;

			internal bool <WaitCombatEnd>b__0()
			{
				if (NACops.registered && offc != null && !((Object)(object)offc.officer == (Object)null) && !((NPC)offc.officer).Health.IsDead && !((NPC)offc.officer).Health.IsKnockedOut && !((Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour == (Object)null))
				{
					if ((Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour != (Object)(object)((NPC)offc.officer).Behaviour.CombatBehaviour)
					{
						return (Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour != (Object)(object)offc.officer.PursuitBehaviour;
					}
					return false;
				}
				return true;
			}
		}

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

			private object <>2__current;

			public Property property;

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

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

			[DebuggerHidden]
			public <BeginRaidEvent>d__32(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 (!raidActive)
					{
						raidActive = true;
						SpawnRaidCops(property);
						<>2__current = NACops.Wait1;
						<>1__state = 1;
						return true;
					}
					DebugModule.Log("Raid is already active", "BeginRaidEvent");
					goto IL_00cc;
				case 1:
					<>1__state = -1;
					DebugModule.Log("Sending raid to " + property.propertyName + " (" + property.propertyCode + ")", "BeginRaidEvent");
					NACops.coros.Add(MelonCoroutines.Start(TraverseCurrentToProperty(property)));
					goto IL_00cc;
				case 2:
					{
						<>1__state = -1;
						return false;
					}
					IL_00cc:
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
			}

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

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

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

			private object <>2__current;

			public RaidOfficer offc;

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

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

			[DebuggerHidden]
			public <Despawn>d__53(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 (offc == null || (Object)(object)offc.officer == (Object)null || (Object)(object)((Component)offc.officer).gameObject == (Object)null || !currentRaidOfficers.Contains(offc))
					{
						DebugModule.Log("Raid Officer already marked for despawn", "Despawn");
						return false;
					}
					if (raidOfficersAlive > 0)
					{
						raidOfficersAlive--;
					}
					deadRaidOfficers.Add(offc);
					if (((NPC)offc.officer).Movement.CanMove())
					{
						((NPC)offc.officer).Movement.SetDestination(((NPCEnterableBuilding)PoliceStation.PoliceStations[0]).Doors[0].AccessPoint);
					}
					<>2__current = NACops.Wait30;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					if (NACops.currentSummoned.Contains(offc.officer))
					{
						NACops.currentSummoned.Remove(offc.officer);
					}
					DebugModule.Log("Despawning " + offc.Name, "Despawn");
					NPC component = ((Component)offc.officer).gameObject.GetComponent<NPC>();
					if ((Object)(object)component != (Object)null && NPCManager.NPCRegistry.Contains(component))
					{
						NPCManager.NPCRegistry.Remove(component);
					}
					if ((Object)(object)component != (Object)null && (Object)(object)((Component)component).gameObject != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)component).gameObject);
					}
					if (currentRaidOfficers.Contains(offc))
					{
						currentRaidOfficers.Remove(offc);
					}
					if (currentRaidOfficers.Count == 0)
					{
						DebugModule.Log("Last raid cop despawned", "Despawn");
						if (raidActive)
						{
							ResetRaidEvent();
						}
					}
					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 <DestroyEquipment>d__42 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public RaidOfficer offc;

			private <>c__DisplayClass42_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_088b: Unknown result type (might be due to invalid IL or missing references)
				//IL_09be: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass42_0();
					<>8__1.offc = offc;
					<>8__1.destroyType = ERaidDestroyType.None;
					<>8__1.destroyTarget = null;
					if (<>8__1.offc.role == EOfficerRaidRole.DestroyGrowEquipment)
					{
						List<Pot> buildablesOfType = <>8__1.offc.targetProperty.GetBuildablesOfType<Pot>();
						List<MushroomBed> buildablesOfType2 = <>8__1.offc.targetProperty.GetBuildablesOfType<MushroomBed>();
						List<DryingRack> buildablesOfType3 = <>8__1.offc.targetProperty.GetBuildablesOfType<DryingRack>();
						if (buildablesOfType != null && buildablesOfType.Count > 0 && buildablesOfType.Count >= buildablesOfType2.Count && buildablesOfType.Count >= buildablesOfType3.Count)
						{
							DebugModule.Log("select pots", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyPot;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<Pot>(buildablesOfType, containers: false);
						}
						else if (buildablesOfType2 != null && buildablesOfType2.Count > 0 && buildablesOfType2.Count >= buildablesOfType.Count && buildablesOfType2.Count >= buildablesOfType3.Count)
						{
							DebugModule.Log("select shroombeds", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyShroomBed;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<MushroomBed>(buildablesOfType2, containers: false);
						}
						else
						{
							if (buildablesOfType3 == null || buildablesOfType3.Count <= 0)
							{
								DebugModule.Log("no selectable item types left", <>8__1.offc.Name);
								<>8__1.offc.currentActionIter = maxActionIters;
								BeginRoleAction(<>8__1.offc);
								return false;
							}
							DebugModule.Log("select drying racks", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyDryingRack;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<DryingRack>(buildablesOfType3, containers: false);
						}
					}
					else if (<>8__1.offc.role == EOfficerRaidRole.DestroyLabEquipment)
					{
						List<MixingStationMk2> buildablesOfType4 = <>8__1.offc.targetProperty.GetBuildablesOfType<MixingStationMk2>();
						List<LabOven> buildablesOfType5 = <>8__1.offc.targetProperty.GetBuildablesOfType<LabOven>();
						List<ChemistryStation> buildablesOfType6 = <>8__1.offc.targetProperty.GetBuildablesOfType<ChemistryStation>();
						List<Cauldron> buildablesOfType7 = <>8__1.offc.targetProperty.GetBuildablesOfType<Cauldron>();
						if (buildablesOfType4 != null && buildablesOfType4.Count > 0)
						{
							DebugModule.Log("select mixing station mk2", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyMixing;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<MixingStationMk2>(buildablesOfType4, containers: false);
						}
						else if (buildablesOfType5 != null && buildablesOfType5.Count > 0 && buildablesOfType5.Count >= buildablesOfType6.Count && buildablesOfType5.Count >= buildablesOfType7.Count)
						{
							DebugModule.Log("select lab ovens", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyLabOven;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<LabOven>(buildablesOfType5, containers: false);
						}
						else if (buildablesOfType6 != null && buildablesOfType6.Count > 0 && buildablesOfType6.Count >= buildablesOfType5.Count && buildablesOfType6.Count >= buildablesOfType7.Count)
						{
							DebugModule.Log("select chem stations", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyChemistryStation;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<ChemistryStation>(buildablesOfType6, containers: false);
						}
						else
						{
							if (buildablesOfType7 == null || buildablesOfType7.Count <= 0)
							{
								DebugModule.Log("no selectable item types left", <>8__1.offc.Name);
								<>8__1.offc.currentActionIter = maxActionIters;
								BeginRoleAction(<>8__1.offc);
								return false;
							}
							DebugModule.Log("select cauldrons", <>8__1.offc.Name);
							<>8__1.destroyType = ERaidDestroyType.DestroyCauldron;
							<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<Cauldron>(buildablesOfType7, containers: false);
						}
					}
					else if (<>8__1.offc.role == EOfficerRaidRole.SearchContainer)
					{
						List<PlaceableStorageEntity> buildablesOfType8 = <>8__1.offc.targetProperty.GetBuildablesOfType<PlaceableStorageEntity>();
						if (buildablesOfType8 == null || buildablesOfType8.Count <= 0)
						{
							DebugModule.Log("no selectable item types left", <>8__1.offc.Name);
							<>8__1.offc.currentActionIter = maxActionIters;
							BeginRoleAction(<>8__1.offc);
							return false;
						}
						DebugModule.Log("select storage entities", <>8__1.offc.Name);
						<>8__1.destroyTarget = RaidPropertyEvent.GetValidBuildable<PlaceableStorageEntity>(buildablesOfType8, containers: true);
					}
					if ((Object)(object)<>8__1.destroyTarget == (Object)null)
					{
						DebugModule.Log("Destroy Target is null after search", <>8__1.offc.Name);
						<>2__current = NACops.Wait05;
						<>1__state = 1;
						return true;
					}
					<>8__1.entity = null;
					switch (<>8__1.destroyType)
					{
					case ERaidDestroyType.DestroyPot:
						RaidPropertyEvent.Casted<Pot>(<>8__1.destroyTarget, (Action<Pot>)delegate(Pot t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyShroomBed:
						RaidPropertyEvent.Casted<MushroomBed>(<>8__1.destroyTarget, (Action<MushroomBed>)delegate(MushroomBed t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyDryingRack:
						RaidPropertyEvent.Casted<DryingRack>(<>8__1.destroyTarget, (Action<DryingRack>)delegate(DryingRack t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyLabOven:
						RaidPropertyEvent.Casted<LabOven>(<>8__1.destroyTarget, (Action<LabOven>)delegate(LabOven t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyChemistryStation:
						RaidPropertyEvent.Casted<ChemistryStation>(<>8__1.destroyTarget, (Action<ChemistryStation>)delegate(ChemistryStation t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyCauldron:
						RaidPropertyEvent.Casted<Cauldron>(<>8__1.destroyTarget, (Action<Cauldron>)delegate(Cauldron t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.DestroyMixing:
						RaidPropertyEvent.Casted<MixingStationMk2>(<>8__1.destroyTarget, (Action<MixingStationMk2>)delegate(MixingStationMk2 t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					case ERaidDestroyType.None:
						RaidPropertyEvent.Casted<PlaceableStorageEntity>(<>8__1.destroyTarget, (Action<PlaceableStorageEntity>)delegate(PlaceableStorageEntity t)
						{
							<>8__1.entity = ((Component)t).GetComponent<ITransitEntity>();
						});
						break;
					}
					Transform val = null;
					if (<>8__1.entity != null)
					{
						val = NavMeshUtility.GetReachableAccessPoint(<>8__1.entity, (NPC)(object)<>8__1.offc.officer);
					}
					if ((Object)(object)val != (Object)null)
					{
						DebugModule.Log("Reachable Access Point found", <>8__1.offc.Name);
						<>8__1.offc.currentTargetObj = <>8__1.destroyTarget;
						<>8__1.targetInstanceID = ((Object)<>8__1.destroyTarget).GetInstanceID();
						DebugModule.Log($"Set {<>8__1.offc.Name} {<>8__1.offc.role} {((Object)<>8__1.destroyTarget).name} ({<>8__1.targetInstanceID})", "DestroyEquipment");
						<>8__1.walkCallback = null;
						<>8__1.callbackConsumed = false;
						<>8__1.walkCallback = OnTraverseToEntityEnded;
						if (((NPC)<>8__1.offc.officer).Movement.IsPaused)
						{
							((NPC)<>8__1.offc.officer).Movement.ResumeMovement();
						}
						if (!((NPC)<>8__1.offc.officer).Movement.CanGetTo(val.position, 1f))
						{
							<>2__current = NACops.Wait05;
							<>1__state = 3;
							return true;
						}
						if (!((NPC)<>8__1.offc.officer).Movement.CanMove())
						{
							<>2__current = NACops.Wait05;
							<>1__state = 5;
							return true;
						}
						((NPC)<>8__1.offc.officer).Movement.SetDestination(val.position, <>8__1.walkCallback, true, 2f, 1f);
						NACops.coros.Add(MelonCoroutines.Start(WaitEndSetDestination(<>8__1.offc, IsWalkCallbackConsumed)));
						return false;
					}
					DebugModule.Log("No reachable access point found for " + <>8__1.entity.Name, <>8__1.offc.Name);
					<>2__current = NACops.Wait05;
					<>1__state = 2;
					return true;
				}
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					BeginRoleAction(<>8__1.offc);
					return false;
				case 2:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					BeginRoleAction(<>8__1.offc);
					return false;
				case 3:
					<>1__state = -1;
					DebugModule.Log("Officer cant pathfind to target position", <>8__1.offc.Name);
					<>2__current = RemoveToBeDestroyed(<>8__1.destroyTarget, <>8__1.destroyType);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					BeginRoleAction(<>8__1.offc);
					return false;
				case 5:
					<>1__state = -1;
					DebugModule.Log("Officer cant move!", <>8__1.offc.Name);
					<>2__current = RemoveToBeDestroyed(<>8__1.destroyTarget, <>8__1.destroyType);
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					BeginRoleAction(<>8__1.offc);
					return false;
				}
				bool IsWalkCallbackConsumed()
				{
					return ((<>c__DisplayClass42_0)this).callbackConsumed;
				}
				void OnTraverseToEntityEnded(WalkResult result)
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					if (((<>c__DisplayClass42_0)this).walkCallback != null && !((<>c__DisplayClass42_0)this).callbackConsumed)
					{
						((<>c__DisplayClass42_0)this).walkCallback = null;
						((<>c__DisplayClass42_0)this).callbackConsumed = true;
						NACops.coros.Add(MelonCoroutines.Start(WaitRunCallback(((<>c__DisplayClass42_0)this).offc, result, ((<>c__DisplayClass42_0)this).destroyType, ((<>c__DisplayClass42_0)this).destroyTarget, ((<>c__DisplayClass42_0)this).targetInstanceID)));
					}
					else
					{
						DebugModule.Log("Walk callback was null when traverse to entity ended!", ((<>c__DisplayClass42_0)this).offc.Name);
					}
				}
			}

			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 <FadeScaleIcon>d__59 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Image image;

			private float <dur>5__2;

			private float <current>5__3;

			private float <xOrig>5__4;

			private float <yOrig>5__5;

			private Color <origColor>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dur>5__2 = 1f;
					<current>5__3 = 0f;
					<xOrig>5__4 = ((Graphic)image).rectTransform.sizeDelta.x;
					<yOrig>5__5 = ((Graphic)image).rectTransform.sizeDelta.y;
					<origColor>5__6 = ((Graphic)image).color;
					goto IL_011d;
				case 1:
					<>1__state = -1;
					goto IL_011d;
				case 2:
					{
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						((Graphic)image).rectTransform.sizeDelta = new Vector2(<xOrig>5__4, <yOrig>5__5);
						((Graphic)image).color = <origColor>5__6;
						return false;
					}
					IL_011d:
					if (<current>5__3 < <dur>5__2)
					{
						<current>5__3 += Time.deltaTime;
						float num = <current>5__3 / <dur>5__2;
						((Graphic)image).color = SetAlpha(((Graphic)image).color, Mathf.SmoothStep(1f, 0f, num));
						((Graphic)image).rectTransform.sizeDelta = new Vector2(Mathf.SmoothStep(<xOrig>5__4, 0f, num), Mathf.SmoothStep(<yOrig>5__5, 0f, num));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = NACops.Wait5;
					<>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 <FadeUI>d__61 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public float delayUntilStart;

			public bool fadeIn;

			public float durInOut;

			private float <current>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delayUntilStart);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<current>5__2 = 0f;
					if (fadeIn)
					{
						notificationGroup.alpha = 0f;
						((Component)raidSlider).gameObject.SetActive(true);
					}
					goto IL_00f3;
				case 2:
					<>1__state = -1;
					goto IL_00f3;
				case 3:
					{
						<>1__state = -1;
						if (!fadeIn)
						{
							((Component)raidSlider).gameObject.SetActive(false);
							notificationGroup.alpha = 1f;
						}
						return false;
					}
					IL_00f3:
					if (<current>5__2 < durInOut)
					{
						<current>5__2 += Time.deltaTime;
						float num = <current>5__2 / durInOut;
						if (fadeIn)
						{
							notificationGroup.alpha = Mathf.SmoothStep(0f, 1f, num);
						}
						else
						{
							notificationGroup.alpha = Mathf.SmoothStep(1f, 0f, num);
						}
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					if (fadeIn)
					{
						notificationGroup.alpha = 1f;
					}
					else
					{
						notificationGroup.alpha = 0f;
					}
					<>2__current = NACops.Wait01;
					<>1__state = 3;
					return true;
				}
			}

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

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

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

			private object <>2__current;

			public Image image;

			private float <dur>5__2;

			private float <current>5__3;

			private float <xOrig>5__4;

			private float <yOrig>5__5;

			private Color <origColor>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dur>5__2 = 2f;
					<current>5__3 = 0f;
					<xOrig>5__4 = ((Graphic)image).rectTransform.sizeDelta.x;
					<yOrig>5__5 = ((Graphic)image).rectTransform.sizeDelta.y;
					<origColor>5__6 = ((Graphic)image).color;
					goto IL_0168;
				case 1:
					<>1__state = -1;
					goto IL_0168;
				case 2:
					{
						<>1__state = -1;
						if (!NACops.registered)
						{
							return false;
						}
						((Graphic)image).rectTransform.sizeDelta = new Vector2(<xOrig>5__4, <yOrig>5__5);
						((Graphic)image).color = <origColor>5__6;
						return false;
					}
					IL_0168:
					if (<current>5__3 < <dur>5__2)
					{
						<current>5__3 += Time.deltaTime;
						float num = <current>5__3 / <dur>5__2;
						((Graphic)image).color = new Color(Mathf.SmoothStep(<origColor>5__6.r, 1f, num), Mathf.SmoothStep(<origColor>5__6.g, 0f, num), Mathf.SmoothStep(<origColor>5__6.b, 0f, num), Mathf.SmoothStep(<origColor>5__6.a, 0f, num));
						((Graphic)image).rectTransform.sizeDelta = new Vector2(Mathf.SmoothStep(<xOrig>5__4, <xOrig>5__4 * 1.5f, num), Mathf.SmoothStep(<yOrig>5__5, <yOrig>5__5 * 1.5f, num));
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = NACops.Wait5;
					<>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 <LateScareEmployees>d__40 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public RaidOfficer offc;

			private List<Employee> <employees>5__2;

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

			private Employee <employee>5__4;

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

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

			[DebuggerHidden]
			public <LateScareEmployees>d__40(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 4:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<employees>5__2 = null;
				<>7__wrap2 = default(List<Employee>.Enumerator);
				<employee>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0128: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						if (employeesScared)
						{
							result = false;
							break;
						}
						employeesScared = true;
						<>2__current = NACops.Wait5;
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -1;
						if (!NACops.registered || !raidActive)
						{
							result = false;
							break;
						}
						<employees>5__2 = new List<Employee>(offc.targetProperty.Employees);
						if (<employees>5__2.Count == 0)
						{
							result = false;
							break;
						}
						<>7__wrap2 = <employees>5__2.GetEnumerator();
						<>1__state = -3;
						goto IL_014e;
					case 2:
						<>1__state = -3;
						if (!NACops.registered)
						{
							result = false;
							<>m__Finally1();
							break;
						}
						((NPC)<employee>5__4).Behaviour.FleeBehaviour.SetPointToFlee(<employee>5__4.AssignedProperty.EmployeeIdlePoints[0].position);
						((Behaviour)((NPC)<employee>5__4).Behaviour.FleeBehaviour).Activate();
						<employee>5__4 = null;
						goto IL_014e;
					case 3:
						<>1__state = -1;
						if (!NACops.registered)
						{
							result = false;
							break;
						}
						<>7__wrap2 = <employees>5__2.GetEnumerator();
						<>1__state = -4;
						goto IL_0284;
					case 4:
						<>1__state = -4;
						if (!NACops.registered)
						{
							result = false;
							<>m__Finally2();
							break;
						}
						if ((Object)(object)((NPC)<employee>5__4).Behaviour.activeBehaviour != (Object)null && (Object)(object)((NPC)<employee>5__4).Behaviour.activeBehaviour == (Object)(object)((NPC)<employee>5__4).Behaviour.FleeBehaviour)
						{
							((Behaviour)((NPC)<employee>5__4).Behaviour.FleeBehaviour).Deactivate();
							((NPC)<employee>5__4).Movement.SetDestination(<employee>5__4.WaitOutside.IdlePoint);
						}
						<employee>5__4 = null;
						goto IL_0284;
					case 5:
						{
							<>1__state = -1;
							result = false;
							break;
						}
						IL_0284:
						if (<>7__wrap2.MoveNext())
						{
							<employee>5__4 = <>7__wrap2.Current;
							<>2__current = NACops.Wait05;
							<>1__state = 4;
							result = true;
						}
						else
						{
							<>m__Finally2();
							<>7__wrap2 = default(List<Employee>.Enumerator);
							<>2__current = null;
							<>1__state = 5;
							result = true;
						}
						break;
						IL_014e:
						if (<>7__wrap2.MoveNext())
						{
							<employee>5__4 = <>7__wrap2.Current;
							<>2__current = NACops.Wait05;
							<>1__state = 2;
							result = true;
						}
						else
						{
							<>m__Finally1();
							<>7__wrap2 = default(List<Employee>.Enumerator);
							<>2__current = NACops.Wait30;
							<>1__state = 3;
							result = true;
						}
						break;
					}
				}
				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();
			}

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

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

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

			private object <>2__current;

			public RaidOfficer offc;

			public Vector3 groupPosition;

			private NPCMovement <movement>5__2;

			private float <maxTraversalTime>5__3;

			private float <current>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_023d: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					<current>5__4 += 0.5f;
					if (!officersArrived.Contains(offc))
					{
						_ = <movement>5__2.CurrentDestination;
						if (<movement>5__2.CurrentDestination == Vector3.zero)
						{
							DebugModule.Log("Raid Cop path is failing to V3.zero", "MonitorTraversal");
						}
						if (!CanContinue(offc))
						{
							DebugModule.Log("Officer cant continue while traversal", "MonitorTraversal");
							if (distancesToProperty.ContainsKey(offc))
							{
								distancesToProperty.Remove(offc);
							}
						}
						else
						{
							if (distancesToProperty.ContainsKey(offc))
							{
								distancesToProperty[offc] = Vector3.Distance(<movement>5__2.FootPosition, groupPosition);
							}
							if (!(Vector3.Distance(<movement>5__2.FootPosition, groupPosition) < 5f) && !(<current>5__4 >= <maxTraversalTime>5__3))
							{
								if (!<movement>5__2.HasDestination && <movement>5__2.CanMove())
								{
									DebugModule.Log("Officer does not have destination but can continue, reset", "MonitorTraversal");
									((NPC)offc.officer).Movement.SetDestination(groupPosition);
									if (<movement>5__2.IsPaused)
									{
										<movement>5__2.ResumeMovement();
									}
								}
								goto IL_007e;
							}
							DebugModule.Log("Officer arrived", "MonitorTraversal");
							<movement>5__2.EndSetDestination((WalkResult)4);
							officersArrived.Add(offc);
							OnArrivedAtProperty(offc);
							if (officersArrived.Count >= raidOfficersAlive)
							{
								DebugModule.Log("Last Officer arrived", "MonitorTraversal");
							}
						}
					}
					return false;
				}
				<>1__state = -1;
				<movement>5__2 = ((NPC)offc.officer).Movement;
				if (!distancesToProperty.ContainsKey(offc))
				{
					distancesToProperty.Add(offc, Vector3.Distance(<movement>5__2.FootPosition, groupPosition));
				}
				<maxTraversalTime>5__3 = 130f;
				<current>5__4 = 0f;
				goto IL_007e;
				IL_007e:
				<>2__current = NACops.Wait05;
				<>1__state = 1;
				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 <OnWalkToEntity>d__45 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public WalkResult result;

			public RaidOfficer offc;

			public BuildableItem destroyTarget;

			public ERaidDestroyType type;

			public int targetInstanceID;

			private StorageEntity <storage>5__2;

			private EAccessSettings <originalSettings>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 <OnWalkToEntity>d__45(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Invalid comparison between Unknown and I4
				//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_045a: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0421: Unknown result type (might be due to invalid IL or missing references)
				//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_034f: 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_0360: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					DebugModule.Log($"Walk to entity Ended: {result}", offc.Name);
					if ((int)result != 4)
					{
						if (!CanContinue(offc))
						{
							DebugModule.Log("Officer interrupted during traverse to entity", "OnWalkToEntity");
							RemoveToBeDestroyed(destroyTarget, type);
							return false;
						}
						DebugModule.Log("Officer failed traverse and can continue", offc.Name);
						RemoveToBeDestroyed(destroyTarget, type);
						BeginRoleAction(offc);
						return false;
					}
					<>2__current = NACops.Wait2;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!CanContinue(offc))
					{
						RemoveToBeDestroyed(destroyTarget, type);
						DebugModule.Log("Officer cant continue after waiting at entity", offc.Name);
						return false;
					}
					if ((Object)(object)destroyTarget == (Object)null || destroyTarget.IsDestroyed)
					{
						DebugModule.Log($"Destroy Target is null: {(Object)(object)destroyTarget == (Object)null}\nor IsDestroyed: {destroyTarget.IsDestroyed}", offc.Name);
						BeginRoleAction(offc);
						return false;
					}
					string name = ((BaseItemInstance)destroyTarget.ItemInstance).Name;
					switch (type)
					{
					case ERaidDestroyType.DestroyPot:
						RaidPropertyEvent.Casted<Pot>(destroyTarget, (Action<Pot>)delegate(Pot _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyShroomBed:
						RaidPropertyEvent.Casted<MushroomBed>(destroyTarget, (Action<MushroomBed>)delegate(MushroomBed _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyDryingRack:
						RaidPropertyEvent.Casted<DryingRack>(destroyTarget, (Action<DryingRack>)delegate(DryingRack _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyLabOven:
						RaidPropertyEvent.Casted<LabOven>(destroyTarget, (Action<LabOven>)delegate(LabOven _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyChemistryStation:
						RaidPropertyEvent.Casted<ChemistryStation>(destroyTarget, (Action<ChemistryStation>)delegate(ChemistryStation _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyCauldron:
						RaidPropertyEvent.Casted<Cauldron>(destroyTarget, (Action<Cauldron>)delegate(Cauldron _)
						{
							ResetEntityConfig(_.Configuration);
						});
						break;
					case ERaidDestroyType.DestroyMixing:
						RaidPropertyEvent.Casted<MixingStationMk2>(destroyTarget, (Action<MixingStationMk2>)delegate(MixingStationMk2 _)
						{
							ResetEntityConfig(((MixingStation)_).Configuration);
						});
						break;
					}
					if (offc.role != EOfficerRaidRole.SearchContainer)
					{
						if (offc.role != 0)
						{
							((NPC)offc.officer).SetAnimationTrigger("GrabItem");
							DestroyBuiltItem(destroyTarget, targetInstanceID);
							offc.destroyedItems++;
							offc.currentTargetObj = null;
							DebugModule.Log($"Succesfully Destroyed Target: {name} | Total: {offc.destroyedItems}", offc.Name);
							BeginRoleAction(offc);
							return false;
						}
						<>2__current = null;
						<>1__state = 4;
						return true;
					}
					ref StorageEntity reference = ref <storage>5__2;
					BuildableItem obj = destroyTarget;
					reference = ((PlaceableStorageEntity)((obj is PlaceableStorageEntity) ? obj : null)).StorageEntity;
					if ((Object)(object)<storage>5__2 == (Object)null)
					{
						DebugModule.Log("Storage is null after arriving!", offc.Name);
						BeginRoleAction(offc);
						return false;
					}
					<originalSettings>5__3 = <storage>5__2.AccessSettings;
					<storage>5__2.AccessSettings = (EAccessSettings)0;
					<i>5__4 = 0;
					goto IL_04bb;
				}
				case 2:
					<>1__state = -1;
					if (!CanContinue(offc))
					{
						<storage>5__2.AccessSettings = <originalSettings>5__3;
						DebugModule.Log("Officer interrupted during storage emptying", offc.Name);
						return false;
					}
					if (!<storage>5__2.ItemSlots[<i>5__4].IsLocked && <storage>5__2.ItemSlots[<i>5__4].ItemInstance != null && (int)((BaseItemDefinition)<storage>5__2.ItemSlots[<i>5__4].ItemInstance.Definition).legalStatus != 0)
					{
						<>2__current = NACops.Wait05;
						<>1__state = 3;
						return true;
					}
					goto IL_04ab;
				case 3:
					<>1__state = -1;
					if (!CanContinue(offc))
					{
						<storage>5__2.AccessSettings = <originalSettings>5__3;
						DebugModule.Log("Officer interrupted during storage emptying", offc.Name);
						return false;
					}
					((NPC)offc.officer).SetAnimationTrigger("GrabItem");
					<storage>5__2.ItemSlots[<i>5__4].ClearItemInstanceRequested();
					goto IL_04ab;
				case 4:
					{
						<>1__state = -1;
						return false;
					}
					IL_04bb:
					if (<i>5__4 < <storage>5__2.ItemSlots.Count)
					{
						<>2__current = NACops.Wait05;
						<>1__state = 2;
						return true;
					}
					<storage>5__2.AccessSettings = <originalSettings>5__3;
					offc.destroyedItems++;
					offc.currentTargetObj = null;
					DebugModule.Log($"Succesfully Emptied Storage: {<storage>5__2.StorageEntityName} | Total: {offc.destroyedItems}", offc.Name);
					BeginRoleAction(offc);
					return false;
					IL_04ab:
					<i>5__4++;
					goto IL_04bb;
				}
			}

			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 <RaidNotification>d__57 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Property property;

			private float <originalDistance>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0490: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0508: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: 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_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Expected O, but got Unknown
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Expected O, but got Unknown
				//IL_0157: 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_01ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_0203: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0267: 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)
				//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0304: Unknown result type (might be due to invalid IL or missing references)
				//IL_031d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0339: Unknown result type (might be due to invalid IL or missing references)
				//IL_034e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0363: Unknown result type (might be due to invalid IL or missing references)
				//IL_0378: Unknown result type (might be due to invalid IL or missing references)
				//IL_038d: Unknown result type (might be due to invalid IL or missing references)
				//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_0401: Unknown result type (might be due to invalid IL or missing references)
				//IL_0416: Unknown result type (might be due to invalid IL or missing references)
				//IL_042b: Unknown result type (might be due to invalid IL or missing references)
				//IL_043f: Unknown result type (might be due to invalid IL or missing references)
				//IL_055e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0577: Unknown result type (might be due to invalid IL or missing references)
				//IL_0670: Unknown result type (might be due to invalid IL or missing references)
				//IL_0615: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					if (!officersReady && raidActive)
					{
						fillRt.anchoredPosition = new Vector2(0f, 0f);
						handleRt.anchoredPosition = new Vector2(25f, 0f);
						float num2 = 0f;
						float num3 = 0f;
						if (distancesToProperty.Count > 0)
						{
							num3 = <originalDistance>5__2 * (float)distancesToProperty.Count;
							foreach (float value in distancesToProperty.Values)
							{
								num2 += value;
							}
						}
						float num4 = Mathf.Clamp01(num2 / num3);
						if (!(num4 < 0.05f))
						{
							((Graphic)sliderFillImage).color = new Color(1f, num4, num4);
							raidSlider.value = num4;
							goto IL_0517;
						}
						raidSlider.value = 0f;
						((Graphic)sliderFillImage).color = Color.red;
						DebugModule.Log("Detected all arrived", "RaidNotification");
						NACops.coros.Add(MelonCoroutines.Start(HighlightHomeIcon(homeImage)));
						NACops.coros.Add(MelonCoroutines.Start(FadeScaleIcon(handleGunImage)));
					}
					NACops.coros.Add(MelonCoroutines.Start(FadeUI(2f, 2.5f, fadeIn: false)));
					distancesToProperty.Clear();
					return false;
				}
				<>1__state = -1;
				if ((Object)(object)raidSlider == (Object)null)
				{
					HUD val = Object.FindObjectOfType<HUD>();
					GameObject val2 = new GameObject("RaidSlider");
					val2.SetActive(false);
					notificationGroup = val2.AddComponent<CanvasGroup>();
					val2.transform.SetParent(((Component)val.canvas).transform, false);
					raidSlider = val2.AddComponent<Slider>();
					raidSlider.maxValue = 1f;
					raidSlider.minValue = 0f;
					RectTransform component = val2.GetComponent<RectTransform>();
					component.anchoredPosition = new Vector2(0f, 350f);
					component.anchorMax = new Vector2(0.5f, 0.5f);
					component.anchorMin = new Vector2(0.5f, 0.5f);
					component.sizeDelta = new Vector2(600f, 30f);
					GameObject val3 = new GameObject("Fill", new Type[1] { typeof(Image) });
					GameObject val4 = new GameObject("Handle", new Type[1] { typeof(Image) });
					GameObject val5 = new GameObject("HomeIcon", new Type[1] { typeof(Image) });
					GameObject val6 = new GameObject("Text", new Type[1] { typeof(TextMeshProUGUI) });
					val3.transform.SetParent(((Component)raidSlider).transform);
					val4.transform.SetParent(((Component)raidSlider).transform);
					val5.transform.SetParent(((Component)raidSlider).transform);
					val6.transform.SetParent(((Component)raidSlider).transform);
					fillRt = val3.GetComponent<RectTransform>();
					raidSlider.fillRect = fillRt;
					sliderFillImage = val3.GetComponent<Image>();
					fillRt.anchoredPosition3D = new Vector3(0f, 0f, 0f);
					fillRt.anchoredPosition = new Vector2(0f, 0f);
					fillRt.offsetMax = new Vector2(0f, -7.5f);
					fillRt.offsetMin = new Vector2(0f, 7.5f);
					fillRt.pivot = new Vector2(0.5f, 0.5f);
					fillRt.sizeDelta = new Vector2(0f, -15f);
					handleRt = val4.GetComponent<RectTransform>();
					raidSlider.handleRect = handleRt;
					handleGunImage = val4.GetComponent<Image>();
					handleGunImage.overrideSprite = m1911Sprite;
					handleRt.anchoredPosition3D = new Vector3(25f, 0f, 0f);
					handleRt.anchoredPosition = new Vector2(25f, 0f);
					handleRt.offsetMax = new Vector2(50f, 12.5f);
					handleRt.offsetMin = new Vector2(0f, -12.5f);
					handleRt.sizeDelta = new Vector2(50f, 25f);
					RectTransform component2 = val5.GetComponent<RectTransform>();
					component2.anchoredPosition = new Vector2(-350f, 0f);
					component2.anchorMax = new Vector2(0.5f, 0.5f);
					component2.anchorMin = new Vector2(0.5f, 0.5f);
					component2.offsetMax = new Vector2(-325f, 25f);
					component2.offsetMin = new Vector2(-375f, -25f);
					component2.sizeDelta = new Vector2(50f, 50f);
					homeImage = val5.GetComponent<Image>();
					homeImage.overrideSprite = homeSprite;
					RectTransform component3 = val6.GetComponent<RectTransform>();
					component3.anchoredPosition = new Vector2(0f, 30f);
					component3.anchorMax = new Vector2(0.5f, 0.5f);
					component3.anchorMin = new Vector2(0.5f, 0.5f);
					component3.offsetMax = new Vector2(300f, 55f);
					component3.offsetMin = new Vector2(-300f, 5f);
					component3.sizeDelta = new Vector2(600f, 50f);
					raidText = val6.GetComponent<TextMeshProUGUI>();
					((TMP_Text)raidText).fontSize = 20f;
					((TMP_Text)raidText).alignment = (TextAlignmentOptions)258;
					((TMP_Text)raidText).horizontalAlignment = (HorizontalAlignmentOptions)2;
				}
				raidSlider.value = 1f;
				((Graphic)sliderFillImage).color = Color.white;
				((TMP_Text)raidText).text = "The police are raiding " + property.PropertyName + "!";
				NACops.coros.Add(MelonCoroutines.Start(FadeUI(4f, 2.5f, fadeIn: true)));
				<originalDistance>5__2 = Vector3.Distance(((NPC)currentRaidOfficers[0].officer).CenterPoint, currentRaidOfficers[0].targetProperty.NPCSpawnPoint.position);
				goto IL_0517;
				IL_0517:
				<>2__current = NACops.Wait05;
				<>1__state = 1;
				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 <RemoveToBeDestroyed>d__49 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public BuildableItem item;

			public bool containerNotSearched;

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

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

			[DebuggerHidden]
			public <RemoveToBeDestroyed>d__49(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;
					lock (toBeDestroyedLock)
					{
						if ((Object)(object)item != (Object)null)
						{
							int instanceID = ((Object)item).GetInstanceID();
							if (toBeDestroyed.Contains(instanceID))
							{
								toBeDestroyed.Remove(instanceID);
							}
							if (containerNotSearched && searchedContainers.Contains(instanceID))
							{
								searchedContainers.Remove(instanceID);
							}
						}
					}
					<>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 <RemoveToBeDestroyed>d__50 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ERaidDestroyType type;

			public BuildableItem item;

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

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

			[DebuggerHidden]
			public <RemoveToBeDestroyed>d__50(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 (type != 0)
					{
						<>2__current = RemoveToBeDestroyed(item, containerNotSearched: false);
						<>1__state = 1;
						return true;
					}
					<>2__current = RemoveToBeDestroyed(item, containerNotSearched: true);
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				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 <TraverseCurrentToProperty>d__36 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Property property;

			private float <offsetFromCenter>5__2;

			private int <i>5__3;

			private Transform <targetLocation>5__4;

			private List<RaidOfficer>.Enumerator <>7__wrap4;

			private RaidOfficer <offc>5__6;

			private Vector3 <groupPosition>5__7;

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

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

			[DebuggerHidden]
			public <TraverseCurrentToProperty>d__36(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();
					}
				}
				<targetLocation>5__4 = null;
				<>7__wrap4 = default(List<RaidOfficer>.Enumerator);
				<offc>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						NACops.coros.Add(MelonCoroutines.Start(RaidNotification(property)));
						DebugModule.Log("Traverse Raid Cops", "TraverseCurrentToProperty");
						<offsetFromCenter>5__2 = 1.35f;
						<i>5__3 = 0;
						<targetLocation>5__4 = null;
						if (property.propertyCode == "manor")
						{
							<targetLocation>5__4 = ((Component)property).transform.Find("Manor Gate");
						}
						else
						{
							<targetLocation>5__4 = property.NPCSpawnPoint;
						}
						<>7__wrap4 = currentRaidOfficers.GetEnumerator();
						<>1__state = -3;
						goto IL_0247;
					case 1:
						<>1__state = -3;
						if (!NACops.registered)
						{
							result = false;
							<>m__Finally1();
							break;
						}
						((NPC)<offc>5__6.officer).Movement.ObstacleAvoidanceEnabled = true;
						((NPC)<offc>5__6.officer).Movement.Agent.avoidancePriority = 10;
						((NPC)<offc>5__6.officer).Movement.ResumeMovement();
						((NPC)<offc>5__6.officer).Movement.SetDestination(<groupPosition>5__7, (Action<WalkResult>)null, 4f, 5f);
						NACops.coros.Add(MelonCoroutines.Start(MonitorTraversal(<offc>5__6, <groupPosition>5__7)));
						<i>5__3++;
						<offc>5__6 = null;
						goto IL_0247;
					case 2:
						{
							<>1__state = -1;
							result = false;
							break;
						}
						IL_0247:
						if (<>7__wrap4.MoveNext())
						{
							<offc>5__6 = <>7__wrap4.Current;
							Vector3 val = Vector3.zero;
							switch (<i>5__3 % 4)
							{
							case 0:
								val = Vector3.forward;
								break;
							case 1:
								val = Vector3.right;
								break;
							case 2:
								val = Vector3.left;
								break;
							case 3:
								val = Vector3.back;
								break;
							}
							((NPC)<offc>5__6.officer).Movement.GetClosestReachablePoint(<targetLocation>5__4.position + val * <offsetFromCenter>5__2, ref <groupPosition>5__7);
							DebugModule.Log(((object)(Vector3)(ref <groupPosition>5__7)).ToString(), "TraverseCurrentToProperty");
							<>2__current = NACops.Wait1;
							<>1__state = 1;
							result = true;
						}
						else
						{
							<>m__Finally1();
							<>7__wrap4 = default(List<RaidOfficer>.Enumerator);
							<>2__current = null;
							<>1__state = 2;
							result = true;
						}
						break;
					}
				}
				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__wrap4).Dispose();
			}

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

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

			private object <>2__current;

			public RaidOfficer offc;

			private <>c__DisplayClass54_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass54_0();
					<>8__1.offc = offc;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !NACops.registered || <>8__1.offc == null || (Object)(object)<>8__1.offc.officer == (Object)null || ((NPC)<>8__1.offc.officer).Health.IsDead || ((NPC)<>8__1.offc.officer).Health.IsKnockedOut || (Object)(object)((NPC)<>8__1.offc.officer).Behaviour.activeBehaviour == (Object)null || ((Object)(object)((NPC)<>8__1.offc.officer).Behaviour.activeBehaviour != (Object)(object)((NPC)<>8__1.offc.officer).Behaviour.CombatBehaviour && (Object)(object)((NPC)<>8__1.offc.officer).Behaviour.activeBehaviour != (Object)(object)<>8__1.offc.officer.PursuitBehaviour)));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					DebugModule.Log("Combat ended or dead, despawn", <>8__1.offc.Name);
					if (<>8__1.offc != null && !deadRaidOfficers.Contains(<>8__1.offc))
					{
						NACops.coros.Add(MelonCoroutines.Start(Despawn(<>8__1.offc)));
					}
					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 <WaitDayPass>d__31 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass31_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass31_0();
					<>2__current = NACops.Wait5;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !NACops.isSaving && !Singleton<SaveManager>.Instance.IsSaving));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					<>2__current = NACops.Wait5;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					DebugModule.Log("Sleep ended Evaluate Raid", "WaitDayPass");
					lock (NACops.heatConfigLock)
					{
						using (List<Property>.Enumerator enumerator = Property.OwnedProperties.GetEnumerator())
						{
							while (enumerator.MoveNext())
							{
								<>c__DisplayClass31_1 CS$<>8__locals0 = new <>c__DisplayClass31_1
								{
									property = enumerator.Current
								};
								PropertyHeat propertyHeat = NACops.heatConfig.Find((PropertyHeat x) => x.propertyCode == CS$<>8__locals0.property.propertyCode);
								if (propertyHeat != null)
								{
									propertyHeat.daysSinceLastRaid++;
									if (propertyHeat.propertyHeat > 12)
									{
										propertyHeat.propertyHeat--;
									}
								}
							}
						}
						<>8__1.currentHeats = new List<PropertyHeat>(NACops.heatConfig);
						if (<>8__1.currentHeats == null)
						{
							DebugModule.Log("Failed to update heats", "WaitDayPass");
							return false;
						}
						ListExtensions.Shuffle<PropertyHeat>((IList<PropertyHeat>)<>8__1.currentHeats, -1);
						<>8__1.selectedCode = string.Empty;
						<>c__DisplayClass31_2 CS$<>8__locals1 = new <>c__DisplayClass31_2();
						CS$<>8__locals1.CS$<>8__locals1 = <>8__1;
						CS$<>8__locals1.i = CS$<>8__locals1.CS$<>8__locals1.currentHeats.Count - 1;
						while (CS$<>8__locals1.i >= 0)
						{
							if (CS$<>8__locals1.CS$<>8__locals1.currentHeats[CS$<>8__locals1.i].daysSinceLastRaid >= NACops.raidConfig.DaysUntilCanRaid && CS$<>8__locals1.CS$<>8__locals1.currentHeats[CS$<>8__locals1.i].propertyHeat >= NACops.raidConfig.PropertyHeatThreshold)
							{
								Property val = Property.OwnedProperties.Find((Property x) => x.PropertyCode == CS$<>8__locals1.CS$<>8__locals1.currentHeats[CS$<>8__locals1.i].propertyCode);
								if (IsPropertyValidForRaid(val))
								{
									CS$<>8__locals1.CS$<>8__locals1.selectedCode = val.propertyCode;
									NACops.coros.Add(MelonCoroutines.Start(BeginRaidEvent(val)));
									break;
								}
							}
							CS$<>8__locals1.i--;
						}
						if (<>8__1.selectedCode != string.Empty)
						{
							PropertyHeat propertyHeat2 = NACops.heatConfig.Find((PropertyHeat x) => x.propertyCode == <>8__1.selectedCode);
							if (propertyHeat2 != null)
							{
								propertyHeat2.daysSinceLastRaid = 0;
								propertyHeat2.propertyHeat = 0;
							}
						}
					}
					<>2__current = null;
					<>1__state = 4;
					return true;
				case 4:
					<>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 <WaitEndSetDestination>d__46 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Func<bool> checkConsumed;

			public RaidOfficer offc;

			private int <maxWaitSecs>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 <WaitEndSetDestination>d__46(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00a2: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<maxWaitSecs>5__2 = 15;
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					if (checkConsumed())
					{
						return false;
					}
					if (!NACops.registered)
					{
						return false;
					}
					<i>5__3 += 5;
					break;
				}
				if (<i>5__3 < <maxWaitSecs>5__2)
				{
					<>2__current = NACops.Wait5;
					<>1__state = 1;
					return true;
				}
				if (!checkConsumed())
				{
					if ((Object)(object)offc.currentTargetObj != (Object)null && Vector3.Distance(((NPC)offc.officer).CenterPoint, ((Component)offc.currentTargetObj).transform.position) < 2f)
					{
						((NPC)offc.officer).Movement.EndSetDestination((WalkResult)4);
					}
					else
					{
						((NPC)offc.officer).Movement.EndSetDestination((WalkResult)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 <WaitForAllArrived>d__39 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public RaidOfficer offc;

			private int <maxWait>5__2;

			private int <time>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = NACops.Wait2;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					((NPC)offc.officer).Movement.PauseMovement();
					DebugModule.Log("Wait for Arrival", "WaitForAllArrived");
					<maxWait>5__2 = 30;
					<time>5__3 = 0;
					goto IL_00e7;
				case 2:
					<>1__state = -1;
					goto IL_00e7;
				case 3:
					{
						<>1__state = -1;
						return false;
					}
					IL_00e7:
					if (NACops.registered)
					{
						<time>5__3++;
						if (officersArrived.Count < raidOfficersAlive && <time>5__3 < <maxWait>5__2)
						{
							if (!CanContinue(offc))
							{
								DebugModule.Log("RaidOfficer died during arrival wait", "WaitForAllArrived");
								return false;
							}
							<>2__current = NACops.Wait2;
							<>1__state = 2;
							return true;
						}
					}
					if (!CanContinue(offc))
					{
						DebugModule.Log("RaidOfficer cant continue after arrival", "WaitForAllArrived");
						return false;
					}
					((NPC)offc.officer).Movement.SpeedController.AddSpeedControl(new SpeedControl("combat", 5, NACops.raidConfig.ClearPropertySpeed));
					if (Random.Range(0f, 1f) > 0.8f)
					{
						AvatarWeapon currentWeapon = ((NPC)offc.officer).Behaviour.CombatBehaviour.currentWeapon;
						AvatarRangedWeapon val = (AvatarRangedWeapon)(object)((currentWeapon is AvatarRangedWeapon) ? currentWeapon : null);
						if ((Object)(object)val != (Object)null)
						{
							val.SetIsRaised(true);
						}
					}
					officersReady = true;
					BeginRoleAction(offc);
					NACops.coros.Add(MelonCoroutines.Start(LateScareEmployees(offc)));
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
			}

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

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

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

			private object <>2__current;

			public RaidOfficer offc;

			public WalkResult result;

			public ERaidDestroyType type;

			public BuildableItem destroyTarget;

			public int targetInstanceID;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0047: 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 = NACops.Wait1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					NACops.coros.Add(MelonCoroutines.Start(OnWalkToEntity(offc, result, type, destroyTarget, targetInstanceID)));
					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();
			}
		}

		public static readonly List<EVisualState> raiderDisabledVisualStates = new List<EVisualState>
		{
			(EVisualState)1,
			(EVisualState)5,
			(EVisualState)7
		};

		public static readonly int maxSearchAttempts = 8;

		public static readonly int maxActionIters = 12;

		public static Sprite m1911Sprite;

		public static Sprite homeSprite;

		public static Slider raidSlider;

		public static TextMeshProUGUI raidText;

		public static RectTransform fillRt;

		public static RectTransform handleRt;

		public static Image sliderFillImage;

		public static Image homeImage;

		public static Image handleGunImage;

		public static CanvasGroup notificationGroup;

		public static bool raidActive = false;

		private static int raidOfficersAlive = 3;

		public static List<int> raidOfficerObjIDs = new List<int>();

		private static List<RaidOfficer> currentRaidOfficers = new List<RaidOfficer>();

		private static List<RaidOfficer> deadRaidOfficers = new List<RaidOfficer>();

		private static List<RaidOfficer> officersArrived = new List<RaidOfficer>();

		private static bool officersReady = false;

		private static bool employeesScared = false;

		private static Dictionary<RaidOfficer, float> distancesToProperty = new Dictionary<RaidOfficer, float>();

		private static object toBeDestroyedLock = new object();

		private static HashSet<int> toBeDestroyed = new HashSet<int>();

		private static HashSet<int> searchedContainers = new HashSet<int>();

		public static readonly List<string> raidOfficerLines = new List<string> { "We are shutting this business down!", "Get on the ground!", "Hyland Point Police! Drop your weapons!", "We are raiding this property! Do not resist!", "Put your hands in the air!", "We have a cease and desist order!" };

		public static void OnDayPassEvaluateRaid()
		{
			NACops.coros.Add(MelonCoroutines.Start(WaitDayPass()));
		}

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

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

		public static void ResetRaidEvent(bool resetUI = false)
		{
			raidActive = false;
			currentRaidOfficers.Clear();
			deadRaidOfficers.Clear();
			raidOfficersAlive = NACops.raidConfig.RaidCopsCount;
			officersArrived.Clear();
			officersReady = false;
			employeesScared = false;
			distancesToProperty.Clear();
			raidOfficerObjIDs.Clear();
			if (resetUI)
			{
				raidText = null;
				homeSprite = null;
				m1911Sprite = null;
				raidSlider = null;
				fillRt = null;
				handleRt = null;
				sliderFillImage = null;
				homeImage = null;
				handleGunImage = null;
				notificationGroup = null;
			}
			lock (toBeDestroyedLock)
			{
				toBeDestroyed.Clear();
				searchedContainers.Clear();
			}
		}

		public static void SpawnRaidCops(Property targetProperty)
		{
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < NACops.raidConfig.RaidCopsCount; i++)
			{
				PoliceOfficer val = OfficerOverrides.SpawnOfficerRuntime(autoDeactivate: false);
				NACops.currentSummoned.Add(val);
				RaidOfficer item = new RaidOfficer
				{
					Name = ((Object)val).name,
					officer = val,
					role = EOfficerRaidRole.Undecided,
					targetProperty = targetProperty
				};
				((NPC)val).Behaviour.ScheduleManager.DisableSchedule();
				((NPC)val).Movement.PauseMovement();
				((NPC)val).Movement.Agent.areaMask = 57;
				((NPC)val).Movement.Warp(((NPCEnterableBuilding)Singleton<Map>.Instance.PoliceStation).Doors[0].AccessPoint);
				NACops.coros.Add(MelonCoroutines.Start(AvatarUtility.SetRaiderAvatar(val)));
				currentRaidOfficers.Add(item);
				((NPC)val).Health.MaxHealth = 240f;
				((NPC)val).Health.Health = 240f;
				((NPC)val).Behaviour.CombatBehaviour.SetWeapon(((Object)(object)val.GunPrefab != (Object)null) ? val.GunPrefab.AssetPath : string.Empty);
				AvatarWeapon currentWeapon = ((NPC)val).Behaviour.CombatBehaviour.currentWeapon;
				AvatarWeapon obj = ((currentWeapon is AvatarRangedWeapon) ? currentWeapon : null);
				((AvatarRangedWeapon)obj).CanShootWhileMoving = true;
				((AvatarRangedWeapon)obj).Damage = 65f;
				obj.CooldownDuration = 0.6f;
				obj.MinUseRange = 0.1f;
				((AvatarRangedWeapon)obj).MaxFireRate = 0.8f;
				((NPC)val).Movement.SpeedController.AddSpeedControl(new SpeedControl("combat", 5, NACops.raidConfig.TraverseToPropertySpeed));
				raidOfficerObjIDs.Add(((Object)((Component)((Component)val).transform.root).gameObject).GetInstanceID());
				((Behaviour)((NPC)val).Awareness).enabled = false;
				ISightable local = (ISightable)(object)Player.Local;
				Dictionary<EVisualState, StateContainer> dictionary = new Dictionary<EVisualState, StateContainer>();
				if (local == null)
				{
					DebugModule.Log("Warning sightable is null", "SpawnRaidCops");
				}
				else if (((NPC)val).Awareness.VisionCone.stateSettings.ContainsKey(local))
				{
					foreach (KeyValuePair<EVisualState, StateContainer> item2 in ((NPC)val).Awareness.VisionCone.stateSettings[local])
					{
						if (!raiderDisabledVisualStates.Contains(item2.Key))
						{
							dictionary.Add(item2.Key, item2.Value);
						}
					}
				}
				if (dictionary.Count == 0)
				{
					DebugModule.Log("Something failed while applying visual state modification", "SpawnRaidCops");
				}
				else if (local != null)
				{
					((NPC)val).Awareness.VisionCone.stateSettings[local] = dictionary;
				}
				((Behaviour)((NPC)val).Awareness).enabled = true;
			}
			AssignRaidOfficerRole(targetProperty);
			raidOfficersAlive = NACops.raidConfig.RaidCopsCount;
		}

		public static void AssignRaidOfficerRole(Property property)
		{
			int maxOfficersPerRole = 2 * Mathf.Max(1, Mathf.RoundToInt((float)NACops.raidConfig.RaidCopsCount / 3f));
			Dictionary<EOfficerRaidRole, int> assignedCounts = new Dictionary<EOfficerRaidRole, int>
			{
				{
					EOfficerRaidRole.SearchContainer,
					0
				},
				{
					EOfficerRaidRole.DestroyGrowEquipment,
					0
				},
				{
					EOfficerRaidRole.DestroyLabEquipment,
					0
				}
			};
			Dictionary<EOfficerRaidRole, int> totalForRoles = GetTotalForRoles(property);
			DebugModule.Log("Role Select", "AssignRaidOfficerRole");
			foreach (RaidOfficer currentRaidOfficer in currentRaidOfficers)
			{
				List<EOfficerRaidRole> list = (from role in assignedCounts
					where role.Value < maxOfficersPerRole
					select role.Key).ToList();
				if (list == null || list.Count == 0)
				{
					DebugModule.Log("All roles have been fulfilled for raid, cant assign role", "AssignRaidOfficerRole");
					break;
				}
				EOfficerRaidRole eOfficerRaidRole = (currentRaidOfficer.role = (from x in totalForRoles
					where assignedCounts[x.Key] < maxOfficersPerRole
					orderby x.Value descending
					select x).FirstOrDefault().Key);
				totalForRoles[eOfficerRaidRole] -= 4;
				assignedCounts[eOfficerRaidRole]++;
				DebugModule.Log($"Assigned role {eOfficerRaidRole} to {currentRaidOfficer.Name}", "AssignRaidOfficerRole");
			}
		}

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

		[IteratorStateMachine(typeof(<MonitorTraversal>d__37))]
		public static IEnumerator MonitorTraversal(RaidOfficer offc, Vector3 groupPosition)
		{
			//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 <MonitorTraversal>d__37(0)
			{
				offc = offc,
				groupPosition = groupPosition
			};
		}

		public static void OnArrivedAtProperty(RaidOfficer offc)
		{
			NACops.coros.Add(MelonCoroutines.Start(WaitForAllArrived(offc)));
		}

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

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

		public static void BeginRoleAction(RaidOfficer offc)
		{
			offc.currentActionIter++;
			if (offc.currentActionIter >= maxActionIters)
			{
				DebugModule.Log("Officer has exhausted action attempts, despawn", offc.Name);
				if (!deadRaidOfficers.Contains(offc))
				{
					NACops.coros.Add(MelonCoroutines.Start(Despawn(offc)));
				}
				return;
			}
			if (offc.role == EOfficerRaidRole.Undecided)
			{
				DebugModule.Log("Officer has no raid role, despawn", offc.Name);
				if (!deadRaidOfficers.Contains(offc))
				{
					NACops.coros.Add(MelonCoroutines.Start(Despawn(offc)));
				}
				return;
			}
			if (offc.destroyedItems >= NACops.raidConfig.MaxDestroyIters)
			{
				DebugModule.Log("Officer reached max destroy iters, despawn", offc.Name);
				if (!deadRaidOfficers.Contains(offc))
				{
					NACops.coros.Add(MelonCoroutines.Start(Despawn(offc)));
				}
				return;
			}
			if (Random.Range(0f, 1f) > 0.8f)
			{
				((NPC)offc.officer).DialogueHandler.ShowWorldspaceDialogue_5s(raidOfficerLines[Random.Range(0, raidOfficerLines.Count)]);
				((NPC)offc.officer).PlayVO((EVOLineType)2, true);
			}
			NACops.coros.Add(MelonCoroutines.Start(DestroyEquipment(offc)));
		}

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

		public static BuildableItem GetValidBuildable<T>(List<T> buildables, bool containers = false) where T : BuildableItem
		{
			if (buildables == null || buildables.Count == 0)
			{
				DebugModule.Log("Buildables list is null or empty", "GetValidBuildable");
				return null;
			}
			BuildableItem val = null;
			int num = 0;
			bool flag = false;
			lock (toBeDestroyedLock)
			{
				do
				{
					num++;
					if (num >= maxSearchAttempts)
					{
						break;
					}
					val = (BuildableItem)(object)buildables[Random.Range(0, buildables.Count)];
					if ((Object)(object)val == (Object)null || toBeDestroyed.Contains(((Object)val).GetInstanceID()))
					{
						continue;
					}
					if (!containers)
					{
						flag = true;
						break;
					}
					if (containers)
					{
						string iD = ((BaseItemInstance)val.ItemInstance).ID;
						if (iD.IndexOf("safe", StringComparison.OrdinalIgnoreCase) >= 0 || iD.IndexOf("bed", StringComparison.OrdinalIgnoreCase) >= 0 || searchedContainers.Contains(((Object)val).GetInstanceID()))
						{
							continue;
						}
						if (((PlaceableStorageEntity)((val is PlaceableStorageEntity) ? val : null)).StorageEntity.ItemCount > 0)
						{
							flag = true;
						}
					}
					if (!flag)
					{
						val = null;
					}
				}
				while (!flag);
				if ((Object)(object)val != (Object)null && !containers)
				{
					toBeDestroyed.Add(((Object)val).GetInstanceID());
				}
				else if ((Object)(object)val != (Object)null && containers)
				{
					searchedContainers.Add(((Object)val).GetInstanceID());
				}
			}
			return val;
		}

		[IteratorStateMachine(typeof(<WaitRunCallback>d__44))]
		public static IEnumerator WaitRunCallback(RaidOfficer offc, WalkResult result, ERaidDestroyType type, BuildableItem destroyTarget, int targetInstanceID)
		{
			//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 <WaitRunCallback>d__44(0)
			{
				offc = offc,
				result = result,
				type = type,
				destroyTarget = destroyTarget,
				targetInstanceID = targetInstanceID
			};
		}

		[IteratorStateMachine(typeof(<OnWalkToEntity>d__45))]
		public static IEnumerator OnWalkToEntity(RaidOfficer offc, WalkResult result, ERaidDestroyType type, BuildableItem destroyTarget, int targetInstanceID)
		{
			//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 <OnWalkToEntity>d__45(0)
			{
				offc = offc,
				result = result,
				type = type,
				destroyTarget = destroyTarget,
				targetInstanceID = targetInstanceID
			};
		}

		[IteratorStateMachine(typeof(<WaitEndSetDestination>d__46))]
		public static IEnumerator WaitEndSetDestination(RaidOfficer offc, Func<bool> checkConsumed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitEndSetDestination>d__46(0)
			{
				offc = offc,
				checkConsumed = checkConsumed
			};
		}

		public static void Casted<T>(BuildableItem item, Action<T> callback) where T : BuildableItem
		{
			callback((T)(object)((item is T) ? item : null));
		}

		public static void ResetEntityConfig(EntityConfiguration conf)
		{
			conf.Reset();
		}

		[IteratorStateMachine(typeof(<RemoveToBeDestroyed>d__49))]
		public static IEnumerator RemoveToBeDestroyed(BuildableItem item, bool containerNotSearched = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RemoveToBeDestroyed>d__49(0)
			{
				item = item,
				containerNotSearched = containerNotSearched
			};
		}

		[IteratorStateMachine(typeof(<RemoveToBeDestroyed>d__50))]
		public static IEnumerator RemoveToBeDestroyed(BuildableItem item, ERaidDestroyType type = ERaidDestroyType.None)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RemoveToBeDestroyed>d__50(0)
			{
				item = item,
				type = type
			};
		}

		public static void DestroyBuiltItem(BuildableItem item, int targetInstanceID)
		{
			item.Destroy_Server();
		}

		public static bool CanContinue(RaidOfficer offc)
		{
			if (!NACops.registered)
			{
				return false;
			}
			if (((NPC)offc.officer).Health.IsDead || ((NPC)offc.officer).Health.IsKnockedOut)
			{
				DebugModule.Log("Cant continue due to being dead", "CanContinue");
				if (!deadRaidOfficers.Contains(offc))
				{
					NACops.coros.Add(MelonCoroutines.Start(Despawn(offc)));
				}
				return false;
			}
			if ((Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour != (Object)null && ((Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour == (Object)(object)((NPC)offc.officer).Behaviour.CombatBehaviour || (Object)(object)((NPC)offc.officer).Behaviour.activeBehaviour == (Object)(object)offc.officer.PursuitBehaviour))
			{
				DebugModule.Log("Cant continue due to combat or crime status", "CanContinue");
				if (((NPC)offc.officer).Movement.IsPaused)
				{
					((NPC)offc.officer).Movement.ResumeMovement();
				}
				NACops.coros.Add(MelonCoroutines.Start(WaitCombatEnd(offc)));
				return false;
			}
			return true;
		}

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

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

		public static Dictionary<EOfficerRaidRole, int> GetTotalForRoles(Property property)
		{
			List<Pot> buildablesOfType = property.GetBuildablesOfType<Pot>();
			List<MushroomBed> buildablesOfType2 = property.GetBuildablesOfType<MushroomBed>();
			List<DryingRack> buildablesOfType3 = property.GetBuildablesOfType<DryingRack>();
			List<LabOven> buildablesOfType4 = property.GetBuildablesOfType<LabOven>();
			List<ChemistryStation> buildablesOfType5 = property.GetBuildablesOfType<ChemistryStation>();
			List<Cauldron> buildablesOfType6 = property.GetBuildablesOfType<Cauldron>();
			List<MixingStationMk2> buildablesOfType7 = property.GetBuildablesOfType<MixingStationMk2>();
			List<PlaceableStorageEntity> buildablesOfType8 = property.GetBuildablesOfType<PlaceableStorageEntity>();
			int num = buildablesOfType.Count + buildablesOfType2.Count + buildablesOfType3.Count;
			int num2 = buildablesOfType4.Count + buildablesOfType5.Count + buildablesOfType6.Count + buildablesOfType7.Count;
			int count = buildablesOfType8.Count;
			DebugModule.Log("Total valid raidable in Property: " + (num + num2 + count), "GetTotalForRoles");
			DebugModule.Log($"GrowTot: {num} - Pots:{buildablesOfType.Count}, Shroom:{buildablesOfType2.Count}, Drying:{buildablesOfType3.Count}", "GetTotalForRoles");
			DebugModule.Log($"LabTot: {num2} - Ovens:{buildablesOfType4.Count}, Chem:{buildablesOfType5.Count}, Cauldron:{buildablesOfType6.Count}, Mix: {buildablesOfType7.Count}", "GetTotalForRoles");
			DebugModule.Log($"Storage: {count}", "GetTotalForRoles");
			return new Dictionary<EOfficerRaidRole, int>
			{
				{
					EOfficerRaidRole.DestroyGrowEquipment,
					num
				},
				{
					EOfficerRaidRole.DestroyLabEquipment,
					num2
				},
				{
					EOfficerRaidRole.SearchContainer,
					count
				}
			};
		}

		public static bool IsPropertyValidForRaid(Property property)
		{
			if (!property.IsOwned)
			{
				DebugModule.Log("Cant raid unowned properties", "IsPropertyValidForRaid");
				return false;
			}
			if ((Object)(object)property.NPCSpawnPoint == (Object)null)
			{
				DebugModule.Log("Cant raid property without a spawnpoint", "IsPropertyValidForRaid");
				return false;
			}
			if (property is Business)
			{
				DebugModule.Log("Cant start raid on a business", "IsPropertyValidForRaid");
				return false;
			}
			Dictionary<EOfficerRaidRole, int> totalForRoles = GetTotalForRoles(property);
			int num = 0;
			int num2 = 0;
			foreach (KeyValuePair<EOfficerRaidRole, int> item in totalForRoles)
			{
				num += item.Value;
				if (item.Value > Mathf.Max(2, Mathf.RoundToInt((float)NACops.raidConfig.MaxDestroyIters * 0.5f) * NACops.raidConfig.RaidCopsCount))
				{
					num2++;
				}
			}
			if (num2 < 2 * Mathf.Max(1, Mathf.RoundToInt((float)NACops.raidConfig.RaidCopsCount / 3f)))
			{
				DebugModule.Log("Property does not have enough built items for raid", "IsPropertyValidForRaid");
				return false;
			}
			return true;
		}

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

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

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

		public static Color SetAlpha(Color c, float a)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return new Color(c.r, c.g, c.b, a);
		}

		[IteratorStateMachine(typeof(<FadeUI>d__61))]
		public static IEnumerator FadeUI(float delayUntilStart, float durInOut, bool fadeIn)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeUI>d__61(0)
			{
				delayUntilStart = delayUntilStart,
				durInOut = durInOut,
				fadeIn = fadeIn
			};
		}

		public static void SetRaidSprite()
		{
			ItemInstance defaultInstance = new Func<string, ItemDefinition>(Registry.GetItem)("m1911").GetDefaultInstance(1);
			IntegerItemInstance val = (IntegerItemInstance)(object)((defaultInstance is IntegerItemInstance) ? defaultInstance : null);
			if (val != null)
			{
				m1911Sprite = ((BaseItemInstance)val).Icon;
			}
			RectTransform iconContainer = Property.Properties[0].PoI.IconContainer;
			Transform val2 = null;
			for (int i = 0; i < ((Transform)iconContainer).childCount; i++)
			{
				Transform child = ((Transform)iconContainer).GetChild(i);
				if (((Object)child).name == "Owned")
				{
					if (child.childCount > 0)
					{
						val2 = child.GetChild(0);
					}
					if ((Object)(object)val2 != (Object)null)
					{
						homeSprite = ((Component)val2).GetComponent<Image>().sprite;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Customer), "SampleOffered")]
	public static class Customer_SampleOffered_Patch
	{
		[CompilerGenerated]
		private sealed class <PreSampleOffered>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Customer customer;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!NACops.currentConfig.SnitchingSamples)
					{
						return false;
					}
					<>2__current = NACops.Wait5;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					float num = default(float);
					Player closestPlayer = Player.GetClosestPlayer(((Component)customer).transform.position, ref num, (List<Player>)null);
					if ((Object)(object)closestPlayer == (Object)null)
					{
						return false;
					}
					var (num2, num3) = ThresholdUtils.Evaluate(NACops.thresholdConfig.SnitchProbability, NetworkSingleton<TimeManager>.Instance.ElapsedDays);
					if (!NACops.currentConfig.DebugMode && Random.Range(num2, num3) < 0.5f)
					{
						return false;
					}
					DebugModule.Log("Snitching Samples", "PreSampleOffered");
					NACops.coros.Add(MelonCoroutines.Start(BaseUtility.LateInvestigation(closestPlayer)));
					NACops.coros.Add(MelonCoroutines.Start(BaseUtility.GiveFalseCharges(1, closestPlayer)));
					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();
			}
		}

		public static bool Prefix(Customer __instance)
		{
			NACops.coros.Add(MelonCoroutines.Start(PreSampleOffered(__instance)));
			return true;
		}

		[IteratorStateMachine(typeof(<PreSampleOffered>d__1))]
		private static IEnumerator PreSampleOffered(Customer customer)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PreSampleOffered>d__1(0)
			{
				customer = customer
			};
		}
	}
	public static class AvatarUtility
	{
		[CompilerGenerated]
		private sealed class <PIAvatar>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

			private AvatarSettings <newSettings>5__2;

			private Vector3 <origPos>5__3;

			private Quaternion <origRot>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Expected O, but got Unknown
				//IL_0162: 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)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: 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_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_029d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_025b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				//IL_0352: Unknown result type (might be due to invalid IL or missing references)
				//IL_0357: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0419: Unknown result type (might be due to invalid IL or missing references)
				//IL_041e: Unknown result type (might be due to invalid IL or missing references)
				//IL_042f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0434: Unknown result type (might be due to invalid IL or missing references)
				//IL_0444: Unknown result type (might be due to invalid IL or missing references)
				//IL_0449: Unknown result type (might be due to invalid IL or missing references)
				//IL_044e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<newSettings>5__2 = ScriptableObject.CreateInstance<AvatarSettings>();
					_ = ((NPC)offc).Avatar.CurrentSettings.AccessorySettings;
					_ = ((NPC)offc).Avatar.CurrentSettings.BodyLayerSettings;
					List<LayerSetting> list = new List<LayerSetting>();
					for (int i = 0; i < 6; i++)
					{
						list.Add(new LayerSetting
						{
							layerPath = "",
							layerTint = Color.white
						});
					}
					List<AccessorySetting> list2 = new List<AccessorySetting>();
					for (int j = 0; j < 9; j++)
					{
						list2.Add(new AccessorySetting
						{
							path = "",
							color = Color.white
						});
					}
					List<Color> list3 = PIColorPalettes[Random.Range(0, PIColorPalettes.Count)];
					<newSettings>5__2.FaceLayerSettings = SetRandomLook(<newSettings>5__2);
					bool flag = false;
					if (<newSettings>5__2.Gender > 0.5f && Random.Range(0f, 1f) > 0.3f)
					{
						flag = true;
						LayerSetting value = list[2];
						value.layerPath = "Avatar/Accessories/Bottom/MediumSkirt/MediumSkirt";
						value.layerTint = list3[0];
						list[2] = value;
					}
					else
					{
						LayerSetting value2 = list[2];
						value2.layerPath = "Avatar/Layers/Bottom/Jeans";
						value2.layerTint = list3[0];
						list[2] = value2;
					}
					if (Random.Range(0f, 1f) > 0.5f)
					{
						LayerSetting value3 = list[3];
						value3.layerPath = "Avatar/Layers/Top/RolledButtonUp";
						value3.layerTint = list3[1];
						list[3] = value3;
					}
					else
					{
						LayerSetting value4 = list[3];
						value4.layerPath = "Avatar/Layers/Top/FlannelButtonUp";
						value4.layerTint = list3[1];
						list[3] = value4;
					}
					AccessorySetting val = list2[0];
					val.path = "Avatar/Accessories/Feet/Sneakers/Sneakers";
					val.color = list3[2];
					list2[0] = val;
					if (Random.Range(0f, 1f) > 0.3f && !flag)
					{
						AccessorySetting val2 = list2[2];
						val2.path = "Avatar/Accessories/Chest/Blazer/Blazer";
						val2.color = list3[3];
						list2[2] = val2;
					}
					if (Random.Range(0f, 1f) > 0.75f)
					{
						AccessorySetting val3 = list2[3];
						val3.path = "Avatar/Accessories/Head/Cap/Cap";
						val3.color = list3[4];
						list2[3] = val3;
					}
					else if (Random.Range(0f, 1f) > 0.9f && <newSettings>5__2.Gender < 0.5f)
					{
						AccessorySetting val4 = list2[3];
						val4.path = "Avatar/Accessories/Head/Beanie/Beanie";
						val4.color = list3[4];
						list2[3] = val4;
						<newSettings>5__2.HairPath = "";
					}
					if (Random.Range(0f, 1f) > 0.8f)
					{
						AccessorySetting val5 = list2[5];
						val5.path = "Avatar/Accessories/Head/LegendSunglasses/LegendSunglasses";
						val5.color = new Color(0.7f, 0.717f, 0.76f);
						list2[5] = val5;
					}
					<newSettings>5__2.AccessorySettings = list2;
					<newSettings>5__2.BodyLayerSettings = list;
					((NPC)offc).Avatar.LoadAvatarSettings(<newSettings>5__2);
					((NPC)offc).FirstName = ((<newSettings>5__2.Gender < 0.5f) ? PrivateInvestigator.randomMaleNames[Random.Range(0, PrivateInvestigator.randomMaleNames.Count)] : PrivateInvestigator.randomFemaleNames[Random.Range(0, PrivateInvestigator.randomFemaleNames.Count)]);
					((Behaviour)((NPC)offc).Movement.Agent).enabled = false;
					((Behaviour)((NPC)offc).Movement).enabled = false;
					<origPos>5__3 = ((Component)offc).transform.position;
					<origRot>5__4 = ((Component)offc).transform.rotation;
					((Component)offc).transform.SetPositionAndRotation(RuntimeImpostor.targetPosition, Quaternion.Euler(RuntimeImpostor.targetRotationEuler));
					((NPC)offc).Avatar.Animation.SetGrounded(true);
					((Behaviour)((NPC)offc).Avatar.Animation).enabled = false;
					<>2__current = NACops.Wait01;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					((Component)((NPC)offc).Avatar.BodyContainer).gameObject.SetActive(true);
					<>2__current = NACops.Wait1;
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					Texture2D impostorTexture = RuntimeImpostor.CreateImpostor(offc);
					((Component)offc).transform.SetPositionAndRotation(<origPos>5__3, <origRot>5__4);
					((Component)((NPC)offc).Avatar.BodyContainer).gameObject.SetActive(false);
					((Behaviour)((NPC)offc).Avatar.Animation).enabled = true;
					((Behaviour)((NPC)offc).Movement.Agent).enabled = true;
					((Behaviour)((NPC)offc).Movement).enabled = true;
					<newSettings>5__2.ImpostorTexture = impostorTexture;
					((NPC)offc).Avatar.Impostor.SetAvatarSettings(<newSettings>5__2);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				case 3:
					<>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 <SetRaiderAvatar>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public PoliceOfficer offc;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: 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_009b: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Expected O, but got Unknown
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_020a: Unknown result type (might be due to invalid IL or missing references)
				//IL_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Unknown result type (might be due to invalid IL or missing references)
				//IL_028d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
					_ = ((NPC)offc).Avatar.CurrentSettings.AccessorySettings;
					_ = ((NPC)offc).Avatar.CurrentSettings.BodyLayerSettings;
					List<LayerSetting> list = new List<LayerSetting>();
					for (int i = 0; i < 6; i++)
					{
						list.Add(new LayerSetting
						{
							layerPath = "",
							layerTint = Color.white
						});
					}
					List<AccessorySetting> list2 = new List<AccessorySetting>();
					for (int j = 0; j < 9; j++)
					{
						list2.Add(new AccessorySetting
						{
							path = "",
							color = Color.white
						});
					}
					LayerSetting value = list[2];
					value.layerPath = "Avatar/Layers/Bottom/Jeans";
					value.layerTint = new Color(0.063f, 0.102f, 0.141f);
					list[2] = value;
					LayerSetting value2 = list[3];
					value2.layerPath = "Avatar/Layers/Top/RolledButtonUp";
					value2.layerTint = new Color(0.012f, 0.161f, 0.31f);
					list[3] = value2;
					LayerSetting value3 = list[4];
					value3.layerPath = "Avatar/Layers/Accessories/FingerlessGloves";
					value3.layerTint = new Color(0.29f, 0.313f, 0.349f);
					list[4] = value3;
					AccessorySetting val2 = list2[0];
					val2.path = "Avatar/Accessories/Feet/CombatBoots/CombatBoots";
					val2.color = new Color(0.47f, 0.462f, 0.4f);
					list2[0] = val2;
					AccessorySetting val3 = list2[1];
					val3.path = "Avatar/Accessories/Waist/PoliceBelt/PoliceBelt";
					val3.color = new Color(0.063f, 0.102f, 0.141f);
					list2[1] = val3;
					AccessorySetting val4 = list2[2];
					val4.path = "Avatar/Accessories/Chest/BulletproofVest/BulletproofVest_Police";
					val4.color = new Color(0.063f, 0.102f, 0.141f);
					list2[2] = val4;
					AccessorySetting val5 = list2[3];
					val5.path = "Avatar/Accessories/Head/PoliceCap/PoliceCap";
					val5.color = new Color(0.29f, 0.313f, 0.349f);
					list2[3] = val5;
					if (Random.Range(0f, 1f) > 0.5f)
					{
						AccessorySetting val6 = list2[5];
						val6.path = "Avatar/Accessories/Head/LegendSunglasses/LegendSunglasses";
						val6.color = new Color(0.7f, 0.717f, 0.76f);
						list2[5] = val6;
					}
					val.FaceLayerSettings = SetRandomLook(val);
					val.AccessorySettings = list2;
					val.BodyLayerSettings = list;
					((NPC)offc).Avatar.LoadAvatarSettings(val);
					<>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();
			}
		}

		public static List<Color> skinColors = new List<Color>
		{
			new Color(0.729412f, 0.596078f, 0.541176f),
			new Color(0.785234f, 0.643633f, 0.584633f),
			new Color(0.364705f, 0.298039f, 0.270588f),
			new Color(0.454902f, 0.372549f, 0.337255f)
		};

		public static List<string> randomFaceLayers = new List<string> { "Avatar/Layers/Face/Face_SmugPout", "Avatar/Layers/Face/Face_SlightSmile", "Avatar/Layers/Face/Face_Neutral" };

		public static List<string> randomMaleHairLayers = new List<string> { "Avatar/Hair/Balding/Balding", "Avatar/Hair/BuzzCut/BuzzCut" };

		public static List<string> randomFemaleHairLayers = new List<string> { "Avatar/Hair/MidFringe/MidFringe", "Avatar/Hair/LowBun/LowBun" };

		public static List<Color> randomHairColors = new List<Color>
		{
			new Color(0.141176f, 0.109803f, 0.066666f),
			new Color(0.666666f, 0.533333f, 0.4f),
			new Color(0.50196f, 0.501965f, 0.5019607f),
			new Color(0.294117f, 0.196078f, 0.121568f)
		};

		public static Dictionary<int, List<Color>> PIColorPalettes = new Dictionary<int, List<Color>>
		{
			{
				0,
				new List<Color>
				{
					new Color(0.396f, 0.396f, 0.396f),
					new Color(0.326f, 0.578f, 0.896f),
					new Color(0.151f, 0.151f, 0.151f),
					new Color(0.613f, 0.493f, 0.344f),
					new Color(0.613f, 0.493f, 0.344f)
				}
			},
			{
				1,
				new List<Color>
				{
					new Color(0.2588f, 0.3647f, 0.549f),
					new Color(0.7137f, 0.2941f, 0.1568f),
					Color.black,
					new Color(0.1372f, 0.1058f, 0.0823f),
					new Color(0.1372f, 0.1058f, 0.0823f)
				}
			},
			{
				2,
				new List<Color>
				{
					new Color(0.258f, 0.364f, 0.549f),
					new Color(0.326f, 0.578f, 0.896f),
					Color.black,
					new Color(0.121f, 0.094f, 0.078f),
					new Color(0.772f, 0.772f, 0.772f)
				}
			},
			{
				3,
				new List<Color>
				{
					new Color(0.615f, 0.478f, 0.313f),
					Color.black,
					Color.black,
					new Color(0.396f, 0.396f, 0.396f),
					new Color(0.772f, 0.772f, 0.772f)
				}
			}
		};

		public static void SetRandomAvatar(PoliceOfficer offc)
		{
			AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
			List<AccessorySetting> accessorySettings = ((NPC)offc).Avatar.CurrentSettings.AccessorySettings;
			List<LayerSetting> bodyLayerSettings = ((NPC)offc).Avatar.CurrentSettings.BodyLayerSettings;
			List<LayerSetting> faceLayerSettings = SetRandomLook(val);
			val.AccessorySettings = new List<AccessorySetting>(accessorySettings);
			val.BodyLayerSettings = new List<LayerSetting>(bodyLayerSettings);
			val.FaceLayerSettings = faceLayerSettings;
			val.FaceLayerSettings = faceLayerSettings;
			((NPC)offc).Avatar.LoadAvatarSettings(val);
		}

		public static List<LayerSetting> SetRandomLook(AvatarSettings newSettings)
		{
			//IL_000e: 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)
			//IL_0027: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			List<LayerSetting> list = new List<LayerSetting>();
			for (int i = 0; i < 6; i++)
			{
				list.Add(new LayerSetting
				{
					layerPath = "",
					layerTint = Color.white
				});
			}
			LayerSetting value = list[0];
			value.layerPath = randomFaceLayers[Random.Range(0, randomFaceLayers.Count)];
			value.layerTint = new Color(0f, 0f, 0f, 1f);
			list[0] = value;
			newSettings.Gender = Random.Range(0f, 0.7f);
			if (Random.Range(0f, 1f) > 0.6f && newSettings.Gender < 0.5f)
			{
				LayerSetting value2 = list[1];
				value2.layerPath = "Avatar/Layers/Face/FacialHair_Goatee";
				value2.layerTint = new Color(0f, 0f, 0f, 1f);
				list[1] = value2;
			}
			LayerSetting value3 = list[3];
			value3.layerPath = "Avatar/Layers/Face/EyeShadow";
			value3.layerTint = new Color(0f, 0f, 0f, 0.96f);
			list[3] = value3;
			LayerSetting value4 = list[4];
			value4.layerPath = "Avatar/Layers/Face/OldPersonWrinkles";
			value4.layerTint = new Color(0f, 0f, 0f, 0.55f);
			list[4] = value4;
			newSettings.UseCombinedLayer = false;
			newSettings.EyebrowScale = Random.Range(1f, 1.1f);
			newSettings.EyebrowThickness = Random.Range(1f, 1.4f);
			newSettings.EyebrowRestingHeight = Random.Range(-1f, -1.4f);
			newSettings.EyeBallTint = new Color(1f, 1f, 1f);
			newSettings.EyeballMaterialIdentifier = "Default";
			newSettings.Height = Random.Range(0.96f, 1.1f);
			newSettings.HairColor = randomHairColors[Random.Range(0, randomHairColors.Count)];
			if (newSettings.Gender < 0.5f)
			{
				newSettings.HairPath = randomMaleHairLayers[Random.Range(0, randomMaleHairLayers.Count)];
			}
			else
			{
				newSettings.HairPath = randomFemaleHairLayers[Random.Range(0, randomFemaleHairLayers.Count)];
			}
			newSettings.Weight = Random.Range(0.65f, 1f);
			newSettings.PupilDilation = 0.55f;
			newSettings.RightEyeLidColor = new Color(0.4118f, 0.3216f, 0.2471f);
			newSettings.LeftEyeLidColor = new Color(0.4118f, 0.3216f, 0.2471f);
			newSettings.RightEyeRestingState = new EyeLidConfiguration
			{
				bottomLidOpen = 0.2719f,
				topLidOpen = 0.4313f
			};
			newSettings.LeftEyeRestingState = new EyeLidConfiguration
			{
				bottomLidOpen = 0.2719f,
				topLidOpen = 0.4313f
			};
			newSettings.SkinColor = skinColors[Random.Range(0, skinColors.Count)];
			return list;
		}

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

		[IteratorStateMachine(typeof(<SetRaiderAvatar>d__9))]
		public static IEnumerator SetRaiderAvatar(PoliceOfficer offc)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetRaiderAvatar>d__9(0)
			{
				offc = offc
			};
		}
	}
	public static class BaseUtility
	{
		[CompilerGenerated]
		private sealed class <AttemptWarp>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Transform target;

			public PoliceOfficer offc;

			private int <maxWarpAttempts>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 <AttemptWarp>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					float num2 = Random.Range(8f, 30f);
					float num3 = Random.Range(8f, 30f);
					num2 *= ((Random.Range(0f, 1f) > 0.5f) ? 1f : (-1f));
					num3 *= ((Random.Range(0f, 1f) > 0.5f) ? 1f : (-1f));
					Vector3 val = target.position + new Vector3(num2, 0f, num3);
					Vector3 val2 = default(Vector3);
					((NPC)offc).Movement.GetClosestReachablePoint(val, ref val2);
					if (val2 != Vector3.zero && !Player.Local.IsPointVisibleToPlayer(val2, 30f, 5f))
					{
						DebugModule.Log("Warp succeeded", "AttemptWarp");
						((NPC)offc).Movement.Warp(val2);
						goto IL_015b;
					}
					<i>5__3++;
				}
				else
				{
					<>1__state = -1;
					Vector3 val2 = Vector3.zero;
					<maxWarpAttempts>5__2 = 10;
					<i>5__3 = 0;
				}
				if (<i>5__3 < <maxWarpAttempts>5__2)
				{
					<>2__current = NACops.Wait05;
					<>1__state = 1;
					return true;
				}
				goto IL_015b;
				IL_015b:
				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 <GiveFalseCharges>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public int severity;

			public Player player;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Expected O, but got Unknown
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!NACops.currentConfig.CorruptCops)
					{
						return false;
					}
					switch (severity)
					{
					case 1:
						player.CrimeData.AddCrime((Crime)new DrugTrafficking(), 1);
						player.CrimeData.AddCrime((Crime)new AttemptingToSell(), 1);
						player.CrimeData.AddCrime((Crime)new Evading(), 1);
						break;
					case 2:
						player.CrimeData.AddCrime((Crime)new FailureToComply(), 10);
						player.CrimeData.AddCrime((Crime)new Evading(), 1);
						break;
					case 3:
						player.CrimeData.AddCrime((Crime)new PossessingHighSeverityDrug(), 60);
						break;
					}
					<>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 <LateInvestigation>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = NACops.Wait1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!NACops.registered || !Singleton<LawManager>.InstanceExists || PoliceStation.PoliceStations.Count == 0)
					{
						return false;
					}
					if (((NPCEnterableBuilding)PoliceStation.GetClosestPoliceStation(((Component)player).transform.position)).OccupantCount < 2)
					{
						return false;
					}
					try
					{
						Singleton<LawManager>.Instance.PoliceCalled(player, (Crime)new DrugTrafficking());
					}
					catch (NullReferenceException ex)
					{
						MelonLogger.Error("Failed to invoke PoliceCalled status " + ex);
					}
					<>2__current = NACops.Wait5;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!NACops.registered)
					{
						return false;
					}
					player.CrimeData.SetPursuitLevel((EPursuitLevel)1);
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>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();
			}
		}

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

		[IteratorStateMachine(typeof(<AttemptWarp>d__1))]
		public static IEnumerator AttemptWarp(PoliceOfficer offc, Transform target)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AttemptWarp>d__1(0)
			{
				offc = offc,
				target = target
			};
		}

		public static bool IsStationNearby(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			return Vector3.Distance(((Component)PoliceStation.GetClosestPoliceStation(pos)).transform.position, pos) < 20f;
		}

		public static void SetPoliceNPC()
		{
			PrefabObjects spawnablePrefabs = NACops.networkManager.SpawnablePrefabs;
			for (int i = 0; i < spawnablePrefabs.GetObjectCount(); i++)
			{
				NetworkObject @object = spawnablePrefabs.GetObject(true, i);
				object obj;
				if (@object == null)
				{
					obj = null;
				}
				else
				{
					GameObject gameObject = ((Component)@object).gameObject;
					obj = ((gameObject != null) ? ((Object)gameObject).name : null);
				}
				if ((string?)obj == "PoliceNPC")
				{
					NACops.policeBase = @object;
					break;
				}
			}
		}

		[IteratorStateMachine(typeof(<GiveFalseCharges>d__4))]
		public static IEnumerator GiveFalseCharges(int severity, Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GiveFalseCharges>d__4(0)
			{
				severity = severity,
				player = player
			};
		}

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

		public static bool CanProceed(PoliceOfficer officer, Player player, float minDist, bool ignoreVehicle = false)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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)
			if (!ignoreVehicle && ((NPC)officer).IsInVehicle)
			{
				return false;
			}
			if (((NPC)officer).isInBuilding)
			{
				return false;
			}
			if (((NPC)officer).Health.IsDead || ((NPC)officer).Health.IsKnockedOut)
			{
				return false;
			}
			if ((Object)(object)player.CurrentProperty != (Object)null)
			{
				return false;
			}
			if ((int)player.CrimeData.CurrentPursuitLevel != 0)
			{
				return false;
			}
			if (!ignoreVehicle && Object.op_Implicit((Object)(object)((NPC)officer).Behaviour.activeBehaviour) && (Object)(object)((NPC)officer).Behaviour.activeBehaviour == (Object)(object)officer.VehiclePatrolBehaviour)
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)((NPC)officer).Behaviour.activeBehaviour) && (Object)(object)((NPC)officer).Behaviour.activeBehaviour == (Object)(object)officer.CheckpointBehaviour)
			{
				return false;
			}
			if (GUIDInUse.Contains(((NPC)officer).BakedGUID))
			{
				return false;
			}
			if (NACops.currentSummoned.Contains(officer))
			{
				return false;
			}
			if (NACops.currentDrugApprehender.Contains(officer))
			{
				return false;
			}
			if (IsStationNearby(player.CenterPointTransform.position))
			{
				return false;
			}
			if (player.CrimeData.BodySearchPending)
			{
				return false;
			}
			if (Vector3.Distance(((NPC)officer).CenterPoint, player.CenterPointTransform.position) > minDist)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PoliceOfficer), "GetNameAddress")]
	public static class PoliceOfficer_GetNameAddress_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(PoliceOfficer __instance, ref string __result)
		{
			if (NACops.currentConfig.PrivateInvestigator && PrivateInvestigator.investigatorObjectIDs.Count > 0 && PrivateInvestigator.investigatorObjectIDs.Contains(((Object)((Component)((Component)__instance).transform.root).gameObject).GetInstanceID()))
			{
				__result = ((NPC)__instance).FirstName;
			}
		}
	}
	[HarmonyPatch(typeof(PursuitBehaviour), "OnCurrentWeaponChanged")]
	public static class PursuitBehaviour_OnCurrentWeaponChanged_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(PursuitBehaviour __instance, AvatarWeapon weapon)
		{
			if (!NACops.currentConfig.PrivateInvestigator)
			{
				return true;
			}
			if ((Object)(object)__instance.officer.belt == (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(VisionCone), "SetSightableStateEnabled")]
	public static class VisionCone_SetSightableStateEnabled_Patch
	{
		[HarmonyPrefix]
		public static bool Prefix(VisionCone __instance, ISightable sightable, EVisualState state, ref bool enabled)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)((Component)((Component)__instance).transform.root).gameObject).GetInstanceID();
			if (NACops.currentPICount != 0 && PrivateInvestigator.investigatorObjectIDs.Contains(instanceID))
			{
				if (PrivateInvestigator.PIdisabledVisualStates.Contains(state))
				{
					return false;
				}
			}
			else if (RaidPropertyEvent.raidActive && RaidPropertyEvent.raidOfficerObjIDs.Contains(instanceID) && RaidPropertyEvent.raiderDisabledVisualStates.Contains(state))
			{
				return false;
			}
			Player val = default(Player);
			if ((int)state == 2 && ((Component)sightable.NetworkObject).TryGetComponent<Player>(ref val) && ((val.CrimeData.MinsSinceLastArrested < 60 && NetworkSingleton<CurfewManager>.Instance.IsHardCurfewActive) || (Object)(object)val.CurrentProperty != (Object)null))
			{
				enabled = false;
			}
			return true;
		}
	}
	[Serializable]
	public class MinMaxThreshold
	{
		public int MinOf { get; set; }

		public float Min { get; set; }

		public float Max { get; set; }

		public MinMaxThreshold(int minOf, float min, float max)
		{
			MinOf = minOf;
			Min = min;
			Max = max;
		}
	}
	public static class ThresholdUtils
	{
		public static (float min, float max) Evaluate(List<MinMaxThreshold> thresholds, int value)
		{
			MinMaxThreshold minMaxThreshold = thresholds[0];
			foreach (MinMaxThreshold threshold in thresholds)
			{
				if (value >= threshold.MinOf)
				{
					minMaxThreshold = threshold;
					continue;
				}
				break;
			}
			return (minMaxThreshold.Min, minMaxThreshold.Max);
		}
	}
	[Serializable]
	public class ThresholdMappings
	{
		public List<MinMaxThreshold> LethalCopFrequency = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 30f, 60f),
			new MinMaxThreshold(5, 20f, 60f),
			new MinMaxThreshold(10, 20f, 50f),
			new MinMaxThreshold(20, 15f, 40f),
			new MinMaxThreshold(30, 10f, 30f),
			new MinMaxThreshold(40, 10f, 20f),
			new MinMaxThreshold(50, 8f, 18f)
		};

		public List<MinMaxThreshold> LethalCopRange = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 1f, 3f),
			new MinMaxThreshold(8000, 1f, 5f),
			new MinMaxThreshold(30000, 2f, 6f),
			new MinMaxThreshold(100000, 3f, 8f),
			new MinMaxThreshold(300000, 4f, 10f),
			new MinMaxThreshold(600000, 9f, 14f),
			new MinMaxThreshold(1000000, 10f, 15f)
		};

		public List<MinMaxThreshold> NearbyCrazyFrequency = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 120f, 400f),
			new MinMaxThreshold(5, 120f, 350f),
			new MinMaxThreshold(10, 100f, 200f),
			new MinMaxThreshold(20, 80f, 100f),
			new MinMaxThreshold(30, 60f, 100f),
			new MinMaxThreshold(40, 50f, 80f),
			new MinMaxThreshold(50, 30f, 80f)
		};

		public List<MinMaxThreshold> NearbyCrazyRange = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 10f, 20f),
			new MinMaxThreshold(8000, 10f, 25f),
			new MinMaxThreshold(30000, 10f, 30f),
			new MinMaxThreshold(100000, 20f, 35f),
			new MinMaxThreshold(300000, 20f, 40f),
			new MinMaxThreshold(500000, 25f, 40f)
		};

		public List<MinMaxThreshold> PIFrequency = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 600f, 1200f),
			new MinMaxThreshold(9000, 500f, 1000f),
			new MinMaxThreshold(30000, 450f, 800f),
			new MinMaxThreshold(50000, 400f, 800f),
			new MinMaxThreshold(80000, 300f, 600f),
			new MinMaxThreshold(300000, 300f, 550f),
			new MinMaxThreshold(500000, 300f, 550f),
			new MinMaxThreshold(900000, 300f, 500f),
			new MinMaxThreshold(1500000, 300f, 500f),
			new MinMaxThreshold(8000000, 300f, 400f)
		};

		public List<MinMaxThreshold> SnitchProbability = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 0f, 0.53f),
			new MinMaxThreshold(5, 0f, 0.65f),
			new MinMaxThreshold(10, 0f, 0.7f),
			new MinMaxThreshold(20, 0f, 0.75f),
			new MinMaxThreshold(30, 0f, 0.85f),
			new MinMaxThreshold(40, 0f, 0.9f),
			new MinMaxThreshold(50, 0.05f, 0.95f),
			new MinMaxThreshold(60, 0.1f, 1f),
			new MinMaxThreshold(70, 0.15f, 1f),
			new MinMaxThreshold(80, 0.2f, 1f),
			new MinMaxThreshold(90, 0.25f, 1f)
		};

		public List<MinMaxThreshold> BuyBustProbability = new List<MinMaxThreshold>
		{
			new MinMaxThreshold(0, 0f, 1f),
			new MinMaxThreshold(5, 0f, 0.9f),
			new MinMaxThreshold(10, 0f, 0.8f),
			new MinMaxThreshold(15, 0f, 0.75f),
			new MinMaxThreshold(20, 0f, 0.65f),
			new MinMaxThreshold(25, 0f, 0.75f),
			new MinMaxThreshold(30, 0f, 0.6f),
			new MinMaxThreshold(40, 0f, 0.55f),
			new MinMaxThreshold(50, 0f, 0.49f)
		};
	}
	[HarmonyPatch(typeof(PropertyDoorController), "CanPlayerAccess")]
	public static class PropertyDoorController_CanPlayerAccess_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(PropertyDoorController __instance, ref EDoorSide side, ref bool __result, ref string reason)
		{
			if (reason != null && NACops.registered && NACops.officerConfig != null && NACops.officerConfig.CanEnterBuildings && reason == "Police are nearby!")
			{
				__result = true;
			}
		}
	}
	public static class RuntimeImpostor
	{
		private static Vector3 cameraPosition = new Vector3(-1.95f, 501f, 0f);

		private static Vector3 cameraRotationEuler = new Vector3(0f, 90f, 0f);

		public static Vector3 targetPosition = new Vector3(0f, 500f, 0f);

		public static Vector3 targetRotationEuler = new Vector3(0f, 0f, 0f);

		private static Vector3 impostorLightPos = new Vector3(-5f, 504f, 0f);

		private static Vector3 impostorLightRot = new Vector3(0f, 0f, 90f);

		public static Dictionary<int, Texture2D> createdTextures = new Dictionary<int, Texture2D>();

		public static Texture2D CreateImpostor(PoliceOfficer officer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_0151: Expected O, but got Unknown
			Texture2D val = null;
			GameObject val2 = new GameObject("TempLight");
			val2.transform.SetPositionAndRotation(impostorLightPos, Quaternion.Euler(impostorLightRot));
			Light obj = val2.AddComponent<Light>();
			obj.range = 20f;
			obj.intensity = 5f;
			GameObject val3 = new GameObject("TempCamera");
			val3.transform.SetPositionAndRotation(cameraPosition, Quaternion.Euler(cameraRotationEuler));
			Camera val4 = val3.AddComponent<Camera>();
			((Behaviour)val4).enabled = false;
			((Component)val4).tag = "Untagged";
			val4.cullingMask = 2049;
			val4.clearFlags = (CameraClearFlags)2;
			val4.backgroundColor = new Color(0f, 0f, 0f, 0f);
			val4.targetTexture = RenderTexture.GetTemporary(128, 128, 24, (RenderTextureFormat)0);
			val4.Render();
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = val4.targetTexture;
			val = new Texture2D(((Texture)val4.targetTexture).width, ((Texture)val4.targetTexture).height, (TextureFormat)5, false);
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)val4.targetTexture).width, (float)((Texture)val4.targetTexture).height), 0, 0);
			val.Apply();
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(val4.targetTexture);
			val4.targetTexture = null;
			Object.Destroy((Object)val3);
			Object.Destroy((Object)val2);
			createdTextures.Add(((Object)officer).GetInstanceID(), val);
			return val;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}