using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using CommonAPI;
using CommonAPI.Systems;
using CommonAPI.Systems.ModLocalization;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using crecheng.DSPModSave;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace System.Runtime.CompilerServices
{
	public record IsExternalInit;
}
namespace DysonSphereProgram.Modding.Blackbox
{
	public class AutoBlackbox
	{
		private int currentBlackboxId;

		private int currentFactoryIdx;

		private int currentStationIdx;

		public bool isActive;

		private int debounceControl;

		private const int saveLogicVersion = 1;

		public void GameTick()
		{
			if (!isActive || DSPGame.IsMenuDemo)
			{
				return;
			}
			debounceControl = (debounceControl + 1) % 60;
			if (debounceControl != 0)
			{
				return;
			}
			if (currentBlackboxId > 0)
			{
				Blackbox blackbox = BlackboxManager.Instance.blackboxes.Find((Blackbox b) => b.Id == currentBlackboxId);
				if (blackbox == null || IsInTerminalState(blackbox.Status))
				{
					currentBlackboxId = 0;
				}
			}
			if (currentBlackboxId != 0)
			{
				return;
			}
			GameData data = GameMain.data;
			currentFactoryIdx %= data.factoryCount;
			PlanetFactory val = data.factories[currentFactoryIdx];
			PlanetTransport transport = val.transport;
			StationComponent[] stationPool = transport.stationPool;
			IEnumerable<Blackbox> source = BlackboxManager.Instance.blackboxes.Where((Blackbox x) => x.FactoryIndex == currentFactoryIdx);
			for (int i = 1; i <= transport.stationCursor; i++)
			{
				int effectiveIdx = (i + currentStationIdx) % transport.stationCursor;
				if (effectiveIdx != 0)
				{
					StationComponent val2 = stationPool[effectiveIdx];
					if (val2 != null && val2.id == effectiveIdx && val2.minerId == 0 && !source.Any((Blackbox b) => b.Selection.stationIds.Contains(effectiveIdx)))
					{
						Plugin.Log.LogDebug((object)("Found unblackboxed stationIdx: " + effectiveIdx));
						currentStationIdx = effectiveIdx;
						Blackbox blackbox2 = BlackboxManager.Instance.CreateForSelection(BlackboxSelection.CreateFrom(val, new int[1] { val2.entityId }));
						currentBlackboxId = blackbox2.Id;
						return;
					}
				}
			}
			for (int j = 1; j <= data.factoryCount; j++)
			{
				int num = (j + currentFactoryIdx) % data.factoryCount;
				if (data.factories[num] != null)
				{
					currentFactoryIdx = num;
					break;
				}
			}
		}

		private bool IsInTerminalState(BlackboxStatus status)
		{
			if (status != BlackboxStatus.Invalid && status != BlackboxStatus.AnalysisFailed)
			{
				return status == BlackboxStatus.Blackboxed;
			}
			return true;
		}

		public void Export(BinaryWriter w)
		{
			w.Write(1);
			w.Write(isActive);
			w.Write(currentBlackboxId);
			w.Write(currentFactoryIdx);
			w.Write(currentStationIdx);
		}

		public void Import(BinaryReader r)
		{
			r.ReadInt32();
			isActive = r.ReadBoolean();
			currentBlackboxId = r.ReadInt32();
			currentFactoryIdx = r.ReadInt32();
			currentStationIdx = r.ReadInt32();
			debounceControl = 0;
		}
	}
	public enum BlackboxStatus
	{
		Initialized,
		SelectionExpanding,
		SelectionFinalized,
		Fingerprinted,
		Invalid,
		InAnalysis,
		AnalysisFailed,
		RecipeObtained,
		Blackboxed
	}
	public class Blackbox
	{
		public readonly int Id;

		public string Name;

		internal bool analyseInBackground;

		public static bool analyseInBackgroundConfig = true;

		private const int saveLogicVersion = 1;

		public BlackboxSelection Selection { get; private set; }

		public BlackboxFingerprint Fingerprint { get; private set; }

		public BlackboxRecipe Recipe { get; private set; }

		public BlackboxAnalysis Analysis { get; private set; }

		public BlackboxSimulation Simulation { get; private set; }

		public BlackboxStatus Status { get; private set; }

		public int FactoryIndex => Selection.factoryIndex;

		public WeakReference<PlanetFactory> FactoryRef => Selection.factoryRef;

		internal Blackbox(int id, BlackboxSelection selection)
		{
			Id = id;
			Selection = selection;
			Status = BlackboxStatus.Initialized;
			Name = "Blackbox #" + Id;
			analyseInBackground = analyseInBackgroundConfig;
		}

		public void NotifyBlackboxed(BlackboxRecipe recipe)
		{
			if (Status == BlackboxStatus.InAnalysis)
			{
				Recipe = recipe;
				Status = BlackboxStatus.RecipeObtained;
			}
		}

		public void NotifyAnalysisFailed()
		{
			if (Status == BlackboxStatus.InAnalysis)
			{
				Status = BlackboxStatus.AnalysisFailed;
			}
		}

		public void GameTick()
		{
			if (!FactoryRef.TryGetTarget(out var _))
			{
				Plugin.Log.LogError((object)"PlanetFactory instance pulled out from under Blackbox in GameTick");
				return;
			}
			switch (Status)
			{
			case BlackboxStatus.Initialized:
				Status = BlackboxStatus.SelectionExpanding;
				break;
			case BlackboxStatus.SelectionExpanding:
				Selection = BlackboxSelection.Expand(Selection);
				if (BlackboxSelection.IsInvalid(Selection))
				{
					Status = BlackboxStatus.Invalid;
				}
				else
				{
					Status = BlackboxStatus.SelectionFinalized;
				}
				break;
			case BlackboxStatus.SelectionFinalized:
				Fingerprint = BlackboxFingerprint.CreateFrom(Selection);
				Status = BlackboxStatus.Fingerprinted;
				break;
			case BlackboxStatus.Fingerprinted:
				Analysis = new BlackboxBenchmark(this);
				Status = BlackboxStatus.InAnalysis;
				Analysis.Begin();
				break;
			case BlackboxStatus.AnalysisFailed:
				Analysis?.Free();
				Analysis = null;
				break;
			case BlackboxStatus.RecipeObtained:
				Analysis?.Free();
				Analysis = null;
				Status = BlackboxStatus.Blackboxed;
				if (Simulation == null)
				{
					Simulation = new BlackboxSimulation(this);
					Simulation.BeginBlackboxing();
				}
				break;
			case BlackboxStatus.Invalid:
			case BlackboxStatus.InAnalysis:
				break;
			}
		}

		public void PreserveVanillaSaveBefore()
		{
			Simulation?.PreserveVanillaSaveBefore();
		}

		public void PreserveVanillaSaveAfter()
		{
			Simulation?.PreserveVanillaSaveAfter();
		}

		public void Export(BinaryWriter w)
		{
			w.Write(1);
			w.Write(Id);
			Selection.Export(w);
			w.Write(Name);
			w.Write(analyseInBackground);
			BlackboxStatus blackboxStatus = Status;
			if (blackboxStatus == BlackboxStatus.InAnalysis)
			{
				blackboxStatus = BlackboxStatus.Fingerprinted;
			}
			w.Write((int)blackboxStatus);
			bool value = Fingerprint != null;
			w.Write(value);
			bool flag = Recipe != null;
			w.Write(flag);
			if (flag)
			{
				Recipe.Export(w);
			}
			bool flag2 = Simulation != null;
			w.Write(flag2);
			if (flag2)
			{
				Simulation.Export(w);
			}
		}

		public static Blackbox Import(BinaryReader r)
		{
			r.ReadInt32();
			int id = r.ReadInt32();
			BlackboxSelection selection = BlackboxSelection.Import(r);
			Blackbox blackbox = new Blackbox(id, selection);
			blackbox.Name = r.ReadString();
			blackbox.analyseInBackground = r.ReadBoolean();
			blackbox.Status = (BlackboxStatus)r.ReadInt32();
			if (r.ReadBoolean())
			{
				blackbox.Fingerprint = BlackboxFingerprint.CreateFrom(blackbox.Selection);
			}
			if (r.ReadBoolean())
			{
				blackbox.Recipe = BlackboxRecipe.Import(r);
			}
			if (r.ReadBoolean())
			{
				blackbox.Simulation = new BlackboxSimulation(blackbox);
				blackbox.Simulation.CreateBlackboxingResources();
				blackbox.Simulation.Import(r);
			}
			return blackbox;
		}
	}
	public abstract class BlackboxAnalysis
	{
		internal Blackbox blackbox;

		internal WeakReference<PlanetFactory> factoryRef;

		public abstract BlackboxRecipe EffectiveRecipe { get; }

		public abstract float Progress { get; }

		public abstract string ProgressText { get; }

		public BlackboxAnalysis(Blackbox blackbox)
		{
			this.blackbox = blackbox;
			factoryRef = blackbox.FactoryRef;
		}

		public abstract void Begin();

		public abstract void Free();
	}
	public struct ProduceConsumePair
	{
		public int Produced;

		public int Consumed;
	}
	public enum BenchmarkPhase
	{
		SpraySaturation,
		SelfSpraySaturation,
		ItemSaturation,
		Benchmarking,
		Averaging
	}
	public record struct StationStorageData(int stationId, int stationIdx, int storageIdx, ELogisticStorage effectiveLogic, int itemId, int itemIdx) : IComparable<StationStorageData>
	{
		public bool isSpray = sprayItemIds.Contains(itemId);

		private static readonly int[] sprayItemIds = new int[3] { 1141, 1142, 1143 };

		public int CompareTo(StationStorageData other)
		{
			int num = stationIdx.CompareTo(other.stationIdx);
			if (num != 0)
			{
				return num;
			}
			return storageIdx.CompareTo(other.storageIdx);
		}

		[CompilerGenerated]
		private readonly bool PrintMembers(StringBuilder builder)
		{
			//IL_0083: 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)
			builder.Append("stationId = ");
			builder.Append(stationId.ToString());
			builder.Append(", stationIdx = ");
			builder.Append(stationIdx.ToString());
			builder.Append(", storageIdx = ");
			builder.Append(storageIdx.ToString());
			builder.Append(", effectiveLogic = ");
			ELogisticStorage val = effectiveLogic;
			builder.Append(((object)(ELogisticStorage)(ref val)).ToString());
			builder.Append(", itemId = ");
			builder.Append(itemId.ToString());
			builder.Append(", itemIdx = ");
			builder.Append(itemIdx.ToString());
			builder.Append(", isSpray = ");
			builder.Append(isSpray.ToString());
			return true;
		}

		[CompilerGenerated]
		public readonly void Deconstruct(out int stationId, out int stationIdx, out int storageIdx, out ELogisticStorage effectiveLogic, out int itemId, out int itemIdx)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected I4, but got Unknown
			stationId = this.stationId;
			stationIdx = this.stationIdx;
			storageIdx = this.storageIdx;
			effectiveLogic = (ELogisticStorage)(int)this.effectiveLogic;
			itemId = this.itemId;
			itemIdx = this.itemIdx;
		}
	}
	public struct StationEntryExit
	{
		public int EntryCount;

		public int EntryInc;

		public int ExitCount;

		public int ExitInc;
	}
	public class BlackboxBenchmark : BlackboxBenchmarkBase
	{
		private class BlackboxBenchmarkSummarizer : ISummarizer<int>
		{
			public BlackboxBenchmark analysis;

			public void Initialize(Span<int> data)
			{
				data.Clear();
			}

			public void Summarize(Span<int> detailed, Span<int> summary)
			{
				int num = 1;
				Span<long> span = MemoryMarshal.Cast<int, long>(detailed.Slice(0, num * 2));
				Span<long> span2 = MemoryMarshal.Cast<int, long>(summary.Slice(0, num * 2));
				for (int i = 0; i < span2.Length; i++)
				{
					span2[i] += span[i];
				}
				Span<int> span3 = detailed.Slice(analysis.stationOffset, analysis.stationSize + analysis.factoryStatsSize + analysis.stationStatsSize);
				Span<int> span4 = summary.Slice(analysis.stationOffset, analysis.stationSize + analysis.factoryStatsSize + analysis.stationStatsSize);
				for (int j = 0; j < span4.Length; j++)
				{
					span4[j] += span3[j];
				}
				Span<int> span5 = detailed.Slice(analysis.statsDiffOffset, analysis.statsDiffSize);
				Span<int> span6 = summary.Slice(analysis.statsDiffOffset, analysis.statsDiffSize);
				for (int k = 0; k < span6.Length; k++)
				{
					span6[k] = Math.Max(span6[k], span5[k]);
				}
			}
		}

		private enum StabilityDetectionAction
		{
			Max,
			Min
		}

		private enum StationEntryExitRecordAction
		{
			EntryBefore,
			EntryAfter,
			ExitBefore,
			ExitAfter
		}

		internal readonly ImmutableSortedSet<int> entityIds;

		internal readonly ImmutableSortedSet<int> pcIds;

		internal readonly ImmutableSortedSet<int> assemblerIds;

		internal readonly ImmutableSortedSet<int> labIds;

		internal readonly ImmutableSortedSet<int> inserterIds;

		internal readonly ImmutableSortedSet<int> stationIds;

		internal readonly ImmutableSortedSet<int> cargoPathIds;

		internal readonly ImmutableSortedSet<int> splitterIds;

		internal readonly ImmutableSortedSet<int> pilerIds;

		internal readonly ImmutableSortedSet<int> spraycoaterIds;

		internal readonly ImmutableSortedSet<int> fractionatorIds;

		internal readonly ImmutableSortedSet<int> itemIds;

		internal StationStorageData[] stationStorages;

		private const int TicksPerSecond = 60;

		private const int TicksPerMinute = 3600;

		public static bool logProfiledData = false;

		public static bool forceNoStackingConfig = false;

		public static bool adaptiveStackingConfig = false;

		public bool adaptiveStacking;

		public bool forceNoStacking;

		public static bool continuousLogging = false;

		private StreamWriter continuousLogger;

		private ProduceConsumePair[] totalStats;

		private ISummarizer<int> summarizer;

		private int[] cycleDetectionData;

		private TimeSeriesData<int> profilingTsData;

		private const int pcOffset = 0;

		private int pcSize;

		private int stationOffset;

		private int stationSize;

		private int factoryStatsOffset;

		private int factoryStatsSize;

		private int stationStatsOffset;

		private int stationStatsSize;

		private int statsDiffOffset;

		private int statsDiffSize;

		private int perTickProfilingSize;

		private int profilingTick;

		private int[] stabilityDetectionData;

		private int stabilizedTick;

		private int spraySaturationTick;

		private int averagingDataSize;

		private long[] averagingDataRaw;

		private int[] averagingDataStats;

		private int averagingDataStatsIdx;

		public static int analysisVerificationCountConfig = 4;

		public static int analysisDurationMultiplierConfig = 3;

		public static float averagingThresholdPcConfig = 0.0001f;

		public static float averagingThresholdItemStatsConfig = 0.0001f;

		public static float stabilityDetectionThresholdConfig = 0f;

		public static bool useItemSaturationPhaseConfig = false;

		public int analysisVerificationCount;

		public int analysisDurationMultiplier;

		public float averagingThresholdPc;

		public float averagingThresholdItemStats;

		public float stabilityDetectionThreshold;

		public bool useItemSaturationPhase;

		private int timeSpendGCD;

		private int timeSpendLCM;

		private int timeSpendMaxIndividual;

		private int profilingTickCount;

		private int profilingEntryCount;

		private int observedCycleLength;

		private BenchmarkPhase phase;

		public static bool shouldOverrideCycleLengthConfig = false;

		public static int overrideCycleLengthConfig = 60;

		public bool shouldOverrideCycleLength;

		public int overrideCycleLength;

		private BlackboxRecipe analysedRecipe;

		internal PlanetFactory simulationFactory;

		internal Task profilingTask;

		internal CancellationTokenSource profilingTaskCancel;

		public override BlackboxRecipe EffectiveRecipe => analysedRecipe;

		public static string FileLogPath => Path.GetDirectoryName(Plugin.Path);

		private int totalTicks => stabilizedTick + profilingTickCount * analysisDurationMultiplier;

		public override float Progress => (float)profilingTick / (float)totalTicks;

		public override string ProgressText => $"{profilingTick} / {totalTicks}";

		public BlackboxBenchmark(Blackbox blackbox)
			: base(blackbox)
		{
			entityIds = blackbox.Selection.entityIds;
			pcIds = blackbox.Selection.pcIds;
			assemblerIds = blackbox.Selection.assemblerIds;
			labIds = blackbox.Selection.labIds;
			inserterIds = blackbox.Selection.inserterIds;
			stationIds = blackbox.Selection.stationIds;
			cargoPathIds = blackbox.Selection.cargoPathIds;
			splitterIds = blackbox.Selection.splitterIds;
			pilerIds = blackbox.Selection.pilerIds;
			spraycoaterIds = blackbox.Selection.spraycoaterIds;
			fractionatorIds = blackbox.Selection.fractionatorIds;
			itemIds = blackbox.Selection.itemIds;
		}

		public override void Begin()
		{
			//IL_0065: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_019f: 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)
			if (!factoryRef.TryGetTarget(out var target))
			{
				Plugin.Log.LogError((object)"PlanetFactory instance pulled out from under BlackboxBenchmark in Begin");
				return;
			}
			simulationFactory = (blackbox.analyseInBackground ? PlanetFactorySimulation.CloneForSimulation(target, blackbox.Selection) : target);
			List<int> list = new List<int>();
			Builder<StationStorageData> val = ImmutableSortedSet.CreateBuilder<StationStorageData>();
			Enumerator<int> enumerator = entityIds.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					int current = enumerator.Current;
					ref EntityData reference = ref simulationFactory.entityPool[current];
					if (reference.assemblerId > 0)
					{
						ref AssemblerComponent reference2 = ref simulationFactory.factorySystem.assemblerPool[reference.assemblerId];
						list.Add(reference2.timeSpend / reference2.speed);
					}
					if (reference.labId > 0)
					{
						ref LabComponent reference3 = ref simulationFactory.factorySystem.labPool[reference.labId];
						LabComponent val2 = reference3;
						if (((LabComponent)(ref val2)).matrixMode)
						{
							list.Add(reference3.timeSpend / 10000);
						}
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
			pcSize = 2;
			stationSize = 0;
			for (int i = 0; i < stationIds.Count; i++)
			{
				ref StationComponent reference4 = ref simulationFactory.transport.stationPool[stationIds[i]];
				for (int j = 0; j < reference4.storage.Length; j++)
				{
					ref StationStore reference5 = ref reference4.storage[j];
					ELogisticStorage effectiveLogic = (((int)reference5.remoteLogic == 0) ? reference5.localLogic : reference5.remoteLogic);
					if (reference5.itemId > 0)
					{
						int itemIdx = itemIds.IndexOf(reference5.itemId);
						val.Add(new StationStorageData(stationIds[i], i, j, effectiveLogic, reference5.itemId, itemIdx));
					}
				}
			}
			stationStorages = ((IEnumerable<StationStorageData>)val.ToImmutable()).ToArray();
			stationSize = stationStorages.Length * 4;
			factoryStatsSize = itemIds.Count * 2;
			stationStatsSize = itemIds.Count * 2;
			statsDiffSize = itemIds.Count;
			stationOffset = pcSize;
			factoryStatsOffset = stationOffset + stationSize;
			stationStatsOffset = factoryStatsOffset + factoryStatsSize;
			statsDiffOffset = stationStatsOffset + stationStatsSize;
			perTickProfilingSize = pcSize + stationSize + factoryStatsSize + stationStatsSize + statsDiffSize;
			totalStats = new ProduceConsumePair[itemIds.Count];
			analysisVerificationCount = analysisVerificationCountConfig;
			analysisDurationMultiplier = analysisDurationMultiplierConfig;
			averagingThresholdPc = averagingThresholdPcConfig;
			averagingThresholdItemStats = averagingThresholdItemStatsConfig;
			stabilityDetectionThreshold = stabilityDetectionThresholdConfig;
			useItemSaturationPhase = useItemSaturationPhaseConfig;
			shouldOverrideCycleLength = shouldOverrideCycleLengthConfig;
			overrideCycleLength = overrideCycleLengthConfig;
			List<int> list2 = list.Distinct().DefaultIfEmpty(60).ToList();
			timeSpendGCD = Math.Max(60, Utils.GCD(list2));
			timeSpendLCM = (int)Utils.LCM(Utils.LCM(list2) * 4, timeSpendGCD);
			timeSpendMaxIndividual = (int)Utils.LCM(list2.Max(), timeSpendGCD);
			profilingTickCount = timeSpendLCM * analysisVerificationCount;
			profilingEntryCount = profilingTickCount / timeSpendGCD;
			MultiLevelGranularity mlg = default(MultiLevelGranularity);
			mlg.levels = 2;
			mlg.entryCounts = new int[2] { timeSpendGCD, profilingEntryCount };
			mlg.ratios = new int[1] { timeSpendGCD };
			summarizer = new BlackboxBenchmarkSummarizer
			{
				analysis = this
			};
			profilingTsData = new TimeSeriesData<int>(perTickProfilingSize, mlg, summarizer);
			cycleDetectionData = new int[perTickProfilingSize * 2];
			stabilityDetectionData = new int[statsDiffSize];
			profilingTick = 0;
			phase = ((spraycoaterIds.Count <= 0) ? (useItemSaturationPhase ? BenchmarkPhase.ItemSaturation : BenchmarkPhase.Benchmarking) : BenchmarkPhase.SpraySaturation);
			averagingDataSize = pcSize + stationSize + factoryStatsSize;
			averagingDataRaw = new long[averagingDataSize];
			averagingDataStats = new int[averagingDataSize * analysisVerificationCount];
			Plugin.Log.LogDebug((object)("Profiling Mem Requirement: " + profilingTsData.Data.Length * 4));
			Plugin.Log.LogDebug((object)("Aggregation ticks: " + timeSpendGCD));
			Plugin.Log.LogDebug((object)("Per-cycle Analysis ticks: " + timeSpendLCM));
			forceNoStacking = forceNoStackingConfig;
			adaptiveStacking = adaptiveStackingConfig;
			if (continuousLogging)
			{
				Directory.CreateDirectory(FileLogPath + "\\DataAnalysis");
				continuousLogger = new StreamWriter($"{FileLogPath}\\DataAnalysis\\BenchmarkV4_CL_{blackbox.Id}.csv");
				WriteContinuousLoggingHeader();
			}
			if (!blackbox.analyseInBackground)
			{
				return;
			}
			profilingTaskCancel = new CancellationTokenSource();
			CancellationToken ct = profilingTaskCancel.Token;
			profilingTask = Task.Factory.StartNew(delegate
			{
				SimulateTillProfilingDone(ct);
			}, profilingTaskCancel.Token, TaskCreationOptions.PreferFairness, TaskScheduler.Default);
			profilingTask.ContinueWith(delegate(Task t)
			{
				Exception ex = t.Exception?.InnerException;
				if (ex != null)
				{
					Plugin.Log.LogError((object)ex);
				}
			}, TaskContinuationOptions.OnlyOnFaulted);
		}

		private void SimulateTillProfilingDone(CancellationToken ct)
		{
			while (blackbox.Status == BlackboxStatus.InAnalysis)
			{
				ct.ThrowIfCancellationRequested();
				PlanetFactorySimulation.SimulateGameTick(this);
			}
		}

		public override void Free()
		{
			if (continuousLogging)
			{
				continuousLogger.Dispose();
				continuousLogger = null;
			}
			analysedRecipe = null;
			if (blackbox.analyseInBackground)
			{
				if (profilingTask != null && profilingTaskCancel != null)
				{
					try
					{
						if (!profilingTask.IsCompleted)
						{
							profilingTaskCancel.Cancel();
							profilingTask.Wait();
						}
					}
					catch (AggregateException ex)
					{
						if (ex.InnerException is OperationCanceledException)
						{
							ManualLogSource log = Plugin.Log;
							int id = blackbox.Id;
							log.LogInfo((object)("Blackbox #" + id + " benchmarking was cancelled"));
						}
						else
						{
							Plugin.Log.LogError((object)ex);
						}
					}
					catch (Exception ex2)
					{
						Plugin.Log.LogError((object)ex2);
					}
					finally
					{
						profilingTaskCancel.Dispose();
						profilingTaskCancel = null;
					}
				}
				PlanetFactorySimulation.FreeSimulationFactory(simulationFactory);
			}
			if (logProfiledData)
			{
				DumpAnalysisToFile();
			}
			simulationFactory = null;
		}

		private void DumpAnalysisToFile()
		{
			Directory.CreateDirectory(FileLogPath + "\\DataAnalysis");
			using FileStream stream = new FileStream($"{FileLogPath}\\DataAnalysis\\BenchmarkV4_{blackbox.Id}.txt", FileMode.Create);
			using StreamWriter streamWriter = new StreamWriter(stream);
			int dataSize = profilingTsData.DataSize;
			streamWriter.WriteLine(dataSize);
			int[] data = profilingTsData.Data;
			int num = data.Length / dataSize;
			int num2 = 0;
			for (int i = 0; i < num; i++)
			{
				Span<long> span = MemoryMarshal.Cast<int, long>(new Span<int>(data, i * dataSize, pcSize));
				for (int j = 0; j < span.Length; j++)
				{
					long value = span[j];
					streamWriter.Write(value);
					streamWriter.Write(" ");
				}
				num2 += pcSize;
				for (int k = pcSize; k < dataSize; k++)
				{
					streamWriter.Write(data[num2++]);
					streamWriter.Write(" ");
				}
				streamWriter.WriteLine();
			}
			streamWriter.WriteLine();
			for (int l = 0; l < itemIds.Count; l++)
			{
				string value2 = LDB.ItemName(itemIds[l]);
				streamWriter.WriteLine(value2);
				ProduceConsumePair produceConsumePair = totalStats[l];
				streamWriter.WriteLine($"  Produced: {produceConsumePair.Produced}");
				streamWriter.WriteLine($"  Consumed: {produceConsumePair.Consumed}");
				streamWriter.WriteLine($"  Difference: {produceConsumePair.Produced - produceConsumePair.Consumed}");
			}
		}

		private void WriteContinuousLoggingHeader()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected I4, but got Unknown
			continuousLogger.Write("Phase,");
			continuousLogger.Write("Tick,");
			continuousLogger.Write("PC,");
			for (int i = 0; i < stationStorages.Length; i++)
			{
				ELogisticStorage effectiveLogic = stationStorages[i].effectiveLogic;
				string arg = (int)effectiveLogic switch
				{
					2 => "D", 
					1 => "S", 
					0 => "N", 
					_ => "U", 
				};
				string arg2 = LDB.ItemName(stationStorages[i].itemId).Replace(" ", "").Trim();
				continuousLogger.Write($"S{i}_{arg}_{arg2}_Entry,");
				continuousLogger.Write($"S{i}_{arg}_{arg2}_EntryInc,");
				continuousLogger.Write($"S{i}_{arg}_{arg2}_Exit,");
				continuousLogger.Write($"S{i}_{arg}_{arg2}_ExitInc,");
			}
			for (int j = 0; j < itemIds.Count; j++)
			{
				string text = LDB.ItemName(itemIds[j]).Replace(" ", "").Trim();
				continuousLogger.Write("F_P_" + text + ",");
				continuousLogger.Write("F_C_" + text + ",");
				continuousLogger.Write("S_P_" + text + ",");
				continuousLogger.Write("S_C_" + text + ",");
			}
			for (int k = 0; k < itemIds.Count; k++)
			{
				string text2 = LDB.ItemName(itemIds[k]).Replace(" ", "").Trim();
				continuousLogger.Write("T_P_" + text2 + ",");
				continuousLogger.Write("T_C_" + text2 + ",");
				continuousLogger.Write("T_D_" + text2 + ",");
			}
			continuousLogger.WriteLine("EOL");
		}

		private void WriteContinuousLoggingData(int level)
		{
			Span<int> span = profilingTsData.LevelEntryOffset(level, profilingTick);
			Span<int> span2 = ((phase == BenchmarkPhase.Averaging) ? new Span<int>(averagingDataStats, averagingDataStatsIdx % analysisVerificationCount, averagingDataSize) : span);
			continuousLogger.Write(phase.ToString());
			continuousLogger.Write(',');
			continuousLogger.Write(profilingTick);
			continuousLogger.Write(',');
			long value = MemoryMarshal.Cast<int, long>(span2.Slice(0, pcSize))[0];
			continuousLogger.Write(value);
			continuousLogger.Write(',');
			Span<StationEntryExit> span3 = MemoryMarshal.Cast<int, StationEntryExit>(span2.Slice(stationOffset, stationSize));
			for (int i = 0; i < stationStorages.Length; i++)
			{
				continuousLogger.Write(span3[i].EntryCount);
				continuousLogger.Write(',');
				continuousLogger.Write(span3[i].EntryInc);
				continuousLogger.Write(',');
				continuousLogger.Write(span3[i].ExitCount);
				continuousLogger.Write(',');
				continuousLogger.Write(span3[i].ExitInc);
				continuousLogger.Write(',');
			}
			Span<ProduceConsumePair> span4 = MemoryMarshal.Cast<int, ProduceConsumePair>(span2.Slice(factoryStatsOffset, factoryStatsSize));
			Span<ProduceConsumePair> span5 = MemoryMarshal.Cast<int, ProduceConsumePair>(span.Slice(stationStatsOffset, stationStatsSize));
			for (int j = 0; j < itemIds.Count; j++)
			{
				continuousLogger.Write(span4[j].Produced);
				continuousLogger.Write(',');
				continuousLogger.Write(span4[j].Consumed);
				continuousLogger.Write(',');
				continuousLogger.Write(span5[j].Produced);
				continuousLogger.Write(',');
				continuousLogger.Write(span5[j].Consumed);
				continuousLogger.Write(',');
			}
			for (int k = 0; k < itemIds.Count; k++)
			{
				continuousLogger.Write(totalStats[k].Produced);
				continuousLogger.Write(',');
				continuousLogger.Write(totalStats[k].Consumed);
				continuousLogger.Write(',');
				continuousLogger.Write(totalStats[k].Produced - totalStats[k].Consumed);
				continuousLogger.Write(',');
			}
			continuousLogger.WriteLine(0);
			if (phase == BenchmarkPhase.Averaging)
			{
				continuousLogger.Write("Averaging Total");
				continuousLogger.Write(',');
				continuousLogger.Write(profilingTick);
				continuousLogger.Write(',');
				continuousLogger.Write(averagingDataRaw[0]);
				continuousLogger.Write(',');
				Span<long> span6 = new Span<long>(averagingDataRaw);
				Span<long> span7 = span6.Slice(stationOffset, stationSize);
				for (int l = 0; l < stationStorages.Length; l++)
				{
					continuousLogger.Write(span7[4 * l]);
					continuousLogger.Write(',');
					continuousLogger.Write(span7[4 * l + 1]);
					continuousLogger.Write(',');
					continuousLogger.Write(span7[4 * l + 2]);
					continuousLogger.Write(',');
					continuousLogger.Write(span7[4 * l + 3]);
					continuousLogger.Write(',');
				}
				Span<long> span8 = span6.Slice(factoryStatsOffset, factoryStatsSize);
				for (int m = 0; m < itemIds.Count; m++)
				{
					continuousLogger.Write(span8[2 * m]);
					continuousLogger.Write(',');
					continuousLogger.Write(span8[2 * m + 1]);
					continuousLogger.Write(',');
					continuousLogger.Write(0);
					continuousLogger.Write(',');
					continuousLogger.Write(0);
					continuousLogger.Write(',');
				}
				for (int n = 0; n < itemIds.Count; n++)
				{
					continuousLogger.Write(totalStats[n].Produced);
					continuousLogger.Write(',');
					continuousLogger.Write(totalStats[n].Consumed);
					continuousLogger.Write(',');
					continuousLogger.Write(totalStats[n].Produced - totalStats[n].Consumed);
					continuousLogger.Write(',');
				}
				continuousLogger.WriteLine(0);
			}
		}

		private void LogItemStats()
		{
			//IL_00ed: 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_00f4: Invalid comparison between Unknown and I4
			//IL_0126: Invalid comparison between Unknown and I4
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick);
			Span<ProduceConsumePair> span2 = MemoryMarshal.Cast<int, ProduceConsumePair>(span.Slice(factoryStatsOffset, factoryStatsSize));
			Span<ProduceConsumePair> span3 = MemoryMarshal.Cast<int, ProduceConsumePair>(span.Slice(stationStatsOffset, stationStatsSize));
			for (int i = 0; i < itemIds.Count; i++)
			{
				span2[i].Consumed += consumeRegister[itemIds[i]];
				span2[i].Produced += productRegister[itemIds[i]];
			}
			Span<StationEntryExit> span4 = MemoryMarshal.Cast<int, StationEntryExit>(span.Slice(stationOffset, stationSize));
			for (int j = 0; j < stationStorages.Length; j++)
			{
				int itemIdx = stationStorages[j].itemIdx;
				ELogisticStorage effectiveLogic = stationStorages[j].effectiveLogic;
				if ((int)effectiveLogic == 1)
				{
					span3[itemIdx].Consumed += span4[j].EntryCount - span4[j].ExitCount;
				}
				if ((int)effectiveLogic == 2)
				{
					span3[itemIdx].Produced += span4[j].ExitCount - span4[j].EntryCount;
				}
			}
		}

		private void LogTotalItemStats()
		{
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick);
			Span<int> span2 = span.Slice(factoryStatsOffset, factoryStatsSize);
			Span<int> span3 = span.Slice(stationStatsOffset, stationStatsSize);
			Span<int> span4 = MemoryMarshal.Cast<ProduceConsumePair, int>(new Span<ProduceConsumePair>(totalStats));
			for (int i = 0; i < span4.Length; i++)
			{
				span4[i] += span2[i];
				span4[i] += span3[i];
			}
			Span<int> span5 = span.Slice(statsDiffOffset, statsDiffSize);
			for (int j = 0; j < totalStats.Length; j++)
			{
				span5[j] = totalStats[j].Produced - totalStats[j].Consumed;
			}
		}

		private void InitializeStabilizationData(int value)
		{
			for (int i = 0; i < stabilityDetectionData.Length; i++)
			{
				stabilityDetectionData[i] = value;
			}
		}

		private void CheckStabilization_V2(StabilityDetectionAction action)
		{
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick).Slice(statsDiffOffset, statsDiffSize);
			for (int i = 0; i < span.Length; i++)
			{
				int num = ((action == StabilityDetectionAction.Max) ? (span[i] - stabilityDetectionData[i]) : (stabilityDetectionData[i] - span[i]));
				int num2 = (int)((float)Math.Abs(stabilityDetectionData[i]) * stabilityDetectionThreshold);
				if (num > num2)
				{
					stabilizedTick = profilingTick;
					stabilityDetectionData[i] = span[i];
				}
			}
		}

		private void CheckStabilization_Max()
		{
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick).Slice(statsDiffOffset, statsDiffSize);
			for (int i = 0; i < span.Length; i++)
			{
				if (span[i] > stabilityDetectionData[i])
				{
					stabilizedTick = profilingTick;
					stabilityDetectionData[i] = span[i];
				}
			}
		}

		private void CheckStabilization_Min()
		{
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick).Slice(statsDiffOffset, statsDiffSize);
			for (int i = 0; i < span.Length; i++)
			{
				if (span[i] < stabilityDetectionData[i])
				{
					stabilizedTick = profilingTick;
					stabilityDetectionData[i] = span[i];
				}
			}
		}

		private void ClearItemStats()
		{
			Span<int> span = profilingTsData.LevelEntryOffset(0, profilingTick);
			span.Slice(0, pcSize).Clear();
			span = profilingTsData.LevelEntryOffset(0, profilingTick);
			span.Slice(factoryStatsOffset, factoryStatsSize).Clear();
			span = profilingTsData.LevelEntryOffset(0, profilingTick);
			span.Slice(stationStatsOffset, stationStatsSize).Clear();
		}

		private void BoostSpraySaturation()
		{
			for (int i = 0; i < spraycoaterIds.Count; i++)
			{
				ref SpraycoaterComponent reference = ref simulationFactory.cargoTraffic.spraycoaterPool[spraycoaterIds[i]];
				if (reference.incCount > 0)
				{
					reference.incCount = reference.incCapacity;
					reference.extraIncCount = 0;
				}
			}
		}

		private void BoostProductionSaturation()
		{
			for (int i = 0; i < assemblerIds.Count; i++)
			{
				ref AssemblerComponent reference = ref simulationFactory.factorySystem.assemblerPool[assemblerIds[i]];
				if (reference.replicating)
				{
					for (int j = 0; j < reference.served.Length; j++)
					{
						reference.served[j] = reference.requireCounts[j] * 3;
					}
					for (int k = 0; k < reference.produced.Length; k++)
					{
						reference.produced[k] = reference.productCounts[k] * 5;
					}
				}
			}
			for (int l = 0; l < labIds.Count; l++)
			{
				ref LabComponent reference2 = ref simulationFactory.factorySystem.labPool[labIds[l]];
				if (reference2.replicating)
				{
					for (int m = 0; m < reference2.served.Length; m++)
					{
						reference2.served[m] = reference2.requireCounts[m] * 3;
					}
					for (int n = 0; n < reference2.produced.Length; n++)
					{
						reference2.produced[n] = reference2.productCounts[n] * 5;
					}
				}
			}
			for (int num = 0; num < fractionatorIds.Count; num++)
			{
				ref FractionatorComponent reference3 = ref simulationFactory.factorySystem.fractionatorPool[fractionatorIds[num]];
				if (reference3.fractionSuccess || reference3.productOutputCount > 0)
				{
					reference3.productOutputCount = reference3.productOutputMax;
					reference3.fluidOutputCount = reference3.fluidOutputMax;
					reference3.fluidInputCount = reference3.fluidInputMax;
				}
			}
		}

		private void EndGameTick_SpraySaturation()
		{
			profilingTsData.SummarizeAtHigherGranularity(profilingTick);
			if (continuousLogging && (profilingTick + 1) % timeSpendGCD == 0)
			{
				WriteContinuousLoggingData(1);
			}
			profilingTick++;
			ClearItemStats();
			BoostSpraySaturation();
			if (profilingTick % timeSpendGCD == 0)
			{
				Plugin.Log.LogDebug((object)("Spray Saturation Tick: " + profilingTick));
				if (profilingTick > timeSpendGCD * analysisVerificationCount)
				{
					int num = profilingTick / timeSpendGCD - 1;
					int num2 = 0;
					if (num > profilingEntryCount)
					{
						num2 = (num - profilingEntryCount) % profilingEntryCount;
						num = profilingEntryCount - 1;
					}
					bool flag = true;
					int num3 = num;
					while (flag && num3 >= num - analysisVerificationCount)
					{
						Span<int> span = profilingTsData.Level(1).Entry((num3 + num2) % profilingEntryCount).Slice(stationOffset, stationSize);
						for (int i = 0; i < stationSize; i++)
						{
							if (span[i] != 0)
							{
								flag = false;
								break;
							}
						}
						num3--;
					}
					if (flag)
					{
						spraySaturationTick = profilingTick;
						phase = BenchmarkPhase.SelfSpraySaturation;
						profilingTick = 0;
						ClearItemStats();
					}
				}
			}
			if (profilingTick >= totalTicks)
			{
				profilingTick = 0;
				Plugin.Log.LogDebug((object)"Analysis Failed");
				blackbox.NotifyAnalysisFailed();
			}
		}

		private void EndGameTick_SelfSpraySaturation()
		{
			profilingTick++;
			BoostSpraySaturation();
			if (profilingTick % timeSpendGCD == 0)
			{
				Plugin.Log.LogDebug((object)("Self Spray Saturation Tick: " + profilingTick));
			}
			if (profilingTick < spraySaturationTick)
			{
				for (int i = 0; i < spraycoaterIds.Count; i++)
				{
					ref SpraycoaterComponent reference = ref simulationFactory.cargoTraffic.spraycoaterPool[spraycoaterIds[i]];
					reference.incCount = 0;
					reference.extraIncCount = 0;
				}
			}
			if (profilingTick >= spraySaturationTick * 2)
			{
				phase = (useItemSaturationPhase ? BenchmarkPhase.ItemSaturation : BenchmarkPhase.Benchmarking);
				profilingTick = 0;
				ClearItemStats();
			}
		}

		private void EndGameTick_ItemSaturation()
		{
			profilingTsData.SummarizeAtHigherGranularity(profilingTick);
			if (continuousLogging && (profilingTick + 1) % timeSpendGCD == 0)
			{
				WriteContinuousLoggingData(1);
			}
			profilingTick++;
			ClearItemStats();
			BoostSpraySaturation();
			BoostProductionSaturation();
			if (profilingTick % timeSpendGCD == 0)
			{
				Plugin.Log.LogDebug((object)("Item Saturation Tick: " + profilingTick));
			}
			if (profilingTick % timeSpendMaxIndividual != 0 || profilingTick <= timeSpendMaxIndividual * analysisVerificationCount)
			{
				return;
			}
			int num = profilingTick / timeSpendGCD - 1;
			int num2 = 0;
			if (num > profilingEntryCount)
			{
				num2 = (num - profilingEntryCount) % profilingEntryCount;
				num = profilingEntryCount - 1;
			}
			int num3 = num - timeSpendMaxIndividual / timeSpendGCD * analysisVerificationCount;
			bool flag = true;
			int num4 = num;
			while (flag && num4 >= num3)
			{
				Span<int> span = profilingTsData.Level(1).Entry((num4 + num2) % profilingEntryCount).Slice(stationOffset, stationSize);
				for (int i = 0; i < stationSize; i++)
				{
					if (span[i] != 0)
					{
						flag = false;
						break;
					}
				}
				num4--;
			}
			if (flag)
			{
				InitializeStabilizationData(int.MaxValue);
				phase = BenchmarkPhase.Benchmarking;
				profilingTick = 0;
				ClearItemStats();
			}
		}

		private void BenchmarkingCycleDetection(int circularOffset, out Func<int, int, bool> indexEquals, out Func<int, int, int, bool> summarizeEquals)
		{
			indexEquals = delegate(int i1, int i2)
			{
				TimeSeriesData<int>.LevelSpan<int> levelSpan2 = profilingTsData.Level(1);
				Span<int> span3 = levelSpan2.Entry((i1 + circularOffset) % profilingEntryCount);
				levelSpan2 = profilingTsData.Level(1);
				Span<int> span4 = levelSpan2.Entry((i2 + circularOffset) % profilingEntryCount);
				for (int k = factoryStatsOffset; k < factoryStatsOffset + factoryStatsSize; k++)
				{
					if (span3[k] != span4[k])
					{
						return false;
					}
				}
				return true;
			};
			summarizeEquals = delegate(int i1, int i2, int stride)
			{
				Span<int> span = new Span<int>(cycleDetectionData, 0, perTickProfilingSize);
				Span<int> span2 = new Span<int>(cycleDetectionData, perTickProfilingSize, perTickProfilingSize);
				summarizer.Initialize(span);
				summarizer.Initialize(span2);
				for (int num = stride - 1; num >= 0; num--)
				{
					TimeSeriesData<int>.LevelSpan<int> levelSpan = profilingTsData.Level(1);
					Span<int> detailed = levelSpan.Entry((i1 - num + circularOffset) % profilingEntryCount);
					levelSpan = profilingTsData.Level(1);
					Span<int> detailed2 = levelSpan.Entry((i2 - num + circularOffset) % profilingEntryCount);
					summarizer.Summarize(detailed, span);
					summarizer.Summarize(detailed2, span2);
				}
				for (int j = factoryStatsOffset; j < factoryStatsOffset + factoryStatsSize; j++)
				{
					if (span[j] != span2[j])
					{
						return false;
					}
				}
				return true;
			};
		}

		private void EndGameTick_Benchmarking()
		{
			LogItemStats();
			LogTotalItemStats();
			CheckStabilization_V2(useItemSaturationPhase ? StabilityDetectionAction.Min : StabilityDetectionAction.Max);
			profilingTsData.SummarizeAtHigherGranularity(profilingTick);
			if (continuousLogging && (profilingTick + 1) % timeSpendGCD == 0)
			{
				WriteContinuousLoggingData(1);
			}
			profilingTick++;
			ClearItemStats();
			if (profilingTick % timeSpendGCD == 0)
			{
				Plugin.Log.LogDebug((object)("Profiling Tick: " + profilingTick));
			}
			if (profilingTick - stabilizedTick > timeSpendLCM && profilingTick % timeSpendLCM == 0)
			{
				Plugin.Log.LogDebug((object)"Checking cycles");
				int num = profilingTick / timeSpendGCD - 1;
				int circularOffset = 0;
				if (num > profilingEntryCount)
				{
					circularOffset = (num - profilingEntryCount) % profilingEntryCount;
					num = profilingEntryCount - 1;
				}
				BenchmarkingCycleDetection(circularOffset, out var indexEquals, out var summarizeEquals);
				if (CycleDetection.TryDetectCycles(num, 0, analysisVerificationCount, indexEquals, summarizeEquals, out var cycleLength))
				{
					int num2 = cycleLength * timeSpendGCD;
					Plugin.Log.LogDebug((object)$"Cycle Length of {num2} detected");
					MoveToAveragingPhase(num2);
				}
			}
			if (profilingTick >= totalTicks)
			{
				int num3 = Math.Min(timeSpendLCM, Math.Max(timeSpendMaxIndividual, 7200));
				Plugin.Log.LogDebug((object)$"Cycle Length of {num3} assumed");
				MoveToAveragingPhase(num3);
			}
		}

		private void MoveToAveragingPhase(int cycleLength)
		{
			observedCycleLength = cycleLength;
			if (shouldOverrideCycleLength)
			{
				Plugin.Log.LogDebug((object)$"Cycle Length overriden to {overrideCycleLength}");
				observedCycleLength = overrideCycleLength;
			}
			profilingTick = 0;
			ClearItemStats();
			phase = BenchmarkPhase.Averaging;
		}

		private void EndGameTick_Averaging()
		{
			LogItemStats();
			LogTotalItemStats();
			profilingTsData.SummarizeAtHigherGranularity(profilingTick);
			if (continuousLogging && (profilingTick + 1) % timeSpendGCD == 0)
			{
				WriteContinuousLoggingData(1);
			}
			profilingTick++;
			ClearItemStats();
			if (profilingTick % timeSpendGCD != 0)
			{
				return;
			}
			Plugin.Log.LogDebug((object)("Averaging Tick: " + profilingTick));
			int num = profilingTick / timeSpendGCD - 1;
			int num2 = 0;
			if (num > profilingEntryCount)
			{
				num2 = (num - profilingEntryCount) % profilingEntryCount;
				num = profilingEntryCount - 1;
			}
			int num3 = observedCycleLength;
			Span<int> span = profilingTsData.Level(1).Entry((num + num2) % profilingEntryCount);
			Span<long> span2 = new Span<long>(averagingDataRaw);
			int num4 = averagingDataStatsIdx % analysisVerificationCount;
			Span<int> span3 = new Span<int>(averagingDataStats, num4 * averagingDataSize, averagingDataSize);
			int num5 = 1;
			Span<long> span4 = MemoryMarshal.Cast<int, long>(span.Slice(0, num5 * 2));
			Span<long> span5 = span2.Slice(0, num5);
			for (int i = 0; i < num5; i++)
			{
				span5[i] += span4[i];
			}
			Span<int> span6 = span.Slice(stationOffset, stationSize);
			Span<long> span7 = span2.Slice(stationOffset, stationSize);
			for (int j = 0; j < stationSize; j++)
			{
				span7[j] += span6[j];
			}
			Span<int> span8 = span.Slice(factoryStatsOffset, factoryStatsSize);
			Span<long> span9 = span2.Slice(factoryStatsOffset, factoryStatsSize);
			for (int k = 0; k < factoryStatsSize; k++)
			{
				span9[k] += span8[k];
			}
			Span<long> span10 = MemoryMarshal.Cast<int, long>(span3.Slice(0, num5 * 2));
			for (int l = 0; l < num5; l++)
			{
				span10[l] = (long)Math.Round((double)(span5[l] * num3) / (double)profilingTick);
			}
			Span<int> span11 = span3.Slice(stationOffset, stationSize);
			for (int m = 0; m < stationSize; m++)
			{
				span11[m] = (int)Math.Round((double)(span7[m] * num3) / (double)profilingTick);
			}
			Span<ProduceConsumePair> span12 = MemoryMarshal.Cast<int, ProduceConsumePair>(span3.Slice(factoryStatsOffset, factoryStatsSize));
			for (int n = 0; n < factoryStatsSize; n++)
			{
				double a = (double)(span9[n] * num3) / (double)profilingTick;
				if (n % 2 == 0)
				{
					span12[n / 2].Produced = (int)Math.Round(a);
				}
				else
				{
					span12[n / 2].Consumed = (int)Math.Round(a);
				}
			}
			averagingDataStatsIdx++;
			bool flag = true;
			double num6 = 0.0;
			long num7 = 0L;
			long num8 = 0L;
			int num9 = 0;
			int num10 = 0;
			int num11 = 0;
			while (flag && num11 < analysisVerificationCount)
			{
				Span<int> span13 = new Span<int>(averagingDataStats, num11 * averagingDataSize, averagingDataSize);
				Span<long> span14 = MemoryMarshal.Cast<int, long>(span13.Slice(0, num5 * 2));
				for (int num12 = 0; num12 < num5; num12++)
				{
					long num13 = Math.Abs(span10[num12] - span14[num12]);
					float num14 = (float)span10[num12] * averagingThresholdPc;
					if (num13 > (long)num14)
					{
						flag = false;
						float num15 = (float)num13 / num14;
						if ((double)num15 > num6)
						{
							num6 = num15;
							num7 = span10[num12];
							num8 = span14[num12];
						}
					}
				}
				Span<int> span15 = span3.Slice(stationOffset, stationSize + factoryStatsSize);
				Span<int> span16 = span13.Slice(stationOffset, stationSize + factoryStatsSize);
				for (int num16 = 0; num16 < stationSize + factoryStatsSize; num16++)
				{
					int num17 = Math.Abs(span15[num16] - span16[num16]);
					float num18 = (float)span15[num16] * averagingThresholdItemStats;
					if (num17 > (int)num18)
					{
						flag = false;
						float num19 = (float)num17 / num18;
						if ((double)num19 > num6)
						{
							num6 = num19;
							num9 = span15[num16];
							num10 = span16[num16];
						}
					}
				}
				num11++;
			}
			if (flag)
			{
				Plugin.Log.LogDebug((object)"Stable!");
				GenerateRecipe_V2();
				blackbox.NotifyBlackboxed(analysedRecipe);
				return;
			}
			Plugin.Log.LogDebug((object)("Deviation: " + num6));
			if (num7 > 0)
			{
				Plugin.Log.LogDebug((object)("Cur Pc : " + num7));
				Plugin.Log.LogDebug((object)("Prev Pc: " + num8));
			}
			if (num9 > 0)
			{
				Plugin.Log.LogDebug((object)("Cur Stats : " + num9));
				Plugin.Log.LogDebug((object)("Prev Stats: " + num10));
			}
		}

		public override void EndGameTick()
		{
			if (blackbox.Status == BlackboxStatus.InAnalysis)
			{
				switch (phase)
				{
				case BenchmarkPhase.SpraySaturation:
					EndGameTick_SpraySaturation();
					break;
				case BenchmarkPhase.SelfSpraySaturation:
					EndGameTick_SelfSpraySaturation();
					break;
				case BenchmarkPhase.ItemSaturation:
					EndGameTick_ItemSaturation();
					break;
				case BenchmarkPhase.Benchmarking:
					EndGameTick_Benchmarking();
					break;
				case BenchmarkPhase.Averaging:
					EndGameTick_Averaging();
					break;
				}
			}
		}

		private void GenerateRecipe_V2()
		{
			//IL_0109: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Invalid comparison between Unknown and I4
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Invalid comparison between Unknown and I4
			long num = 0L;
			for (int i = 0; i < pcIds.Count; i++)
			{
				num += simulationFactory.powerSystem.consumerPool[pcIds[i]].idleEnergyPerTick;
			}
			long num2 = num * observedCycleLength;
			Span<int> span = new Span<int>(averagingDataStats, 0, averagingDataSize);
			long num3 = 0L;
			Span<long> span2 = MemoryMarshal.Cast<int, long>(span.Slice(0, pcSize));
			for (int j = 0; j < span2.Length; j++)
			{
				long num4 = span2[j];
				num3 += num4;
			}
			Dictionary<int, Dictionary<int, CNT>> dictionary = new Dictionary<int, Dictionary<int, CNT>>();
			Dictionary<int, Dictionary<int, CNTINC>> dictionary2 = new Dictionary<int, Dictionary<int, CNTINC>>();
			Span<StationEntryExit> span3 = MemoryMarshal.Cast<int, StationEntryExit>(span.Slice(stationOffset, stationSize));
			for (int k = 0; k < stationStorages.Length; k++)
			{
				int stationIdx = stationStorages[k].stationIdx;
				int itemId = stationStorages[k].itemId;
				ELogisticStorage effectiveLogic = stationStorages[k].effectiveLogic;
				ref StationEntryExit reference = ref span3[k];
				int num5 = reference.ExitCount - reference.EntryCount;
				int num6 = reference.ExitInc - reference.EntryInc;
				if ((int)effectiveLogic == 2 && num5 > 0)
				{
					if (!dictionary.ContainsKey(stationIdx))
					{
						dictionary[stationIdx] = new Dictionary<int, CNT>();
					}
					dictionary[stationIdx][itemId] = new CNT
					{
						count = num5
					};
				}
				else if ((int)effectiveLogic == 1 && num5 < 0)
				{
					if (!dictionary2.ContainsKey(stationIdx))
					{
						dictionary2[stationIdx] = new Dictionary<int, CNTINC>();
					}
					dictionary2[stationIdx][itemId] = new CNTINC
					{
						count = -num5,
						inc = -num6
					};
				}
			}
			Dictionary<int, int> dictionary3 = new Dictionary<int, int>();
			Dictionary<int, int> dictionary4 = new Dictionary<int, int>();
			Span<ProduceConsumePair> span4 = MemoryMarshal.Cast<int, ProduceConsumePair>(span.Slice(factoryStatsOffset, factoryStatsSize));
			for (int l = 0; l < itemIds.Count; l++)
			{
				if (span4[l].Produced > 0)
				{
					dictionary3[itemIds[l]] = span4[l].Produced;
				}
				if (span4[l].Consumed > 0)
				{
					dictionary4[itemIds[l]] = span4[l].Consumed;
				}
			}
			Plugin.Log.LogDebug((object)$"Idle Energy per cycle: {num2}");
			Plugin.Log.LogDebug((object)$"Working Energy per cycle: {num3}");
			Plugin.Log.LogDebug((object)$"Idle Power: {num2 / observedCycleLength * 60}");
			Plugin.Log.LogDebug((object)$"Working Power: {num3 / observedCycleLength * 60}");
			Plugin.Log.LogDebug((object)"Consumed");
			foreach (KeyValuePair<int, int> item in dictionary4)
			{
				string arg = LDB.ItemName(item.Key);
				Plugin.Log.LogDebug((object)$"  {item.Value} {arg}");
			}
			Plugin.Log.LogDebug((object)"Produced");
			foreach (KeyValuePair<int, int> item2 in dictionary3)
			{
				string arg2 = LDB.ItemName(item2.Key);
				Plugin.Log.LogDebug((object)$"  {item2.Value} {arg2}");
			}
			Plugin.Log.LogDebug((object)"Inputs");
			foreach (KeyValuePair<int, Dictionary<int, CNT>> item3 in dictionary)
			{
				Plugin.Log.LogDebug((object)$"  Station #{item3.Key}:");
				foreach (KeyValuePair<int, CNT> item4 in item3.Value)
				{
					string arg3 = LDB.ItemName(item4.Key);
					Plugin.Log.LogDebug((object)$"    {item4.Value} {arg3}");
				}
			}
			Plugin.Log.LogDebug((object)"Outputs");
			foreach (KeyValuePair<int, Dictionary<int, CNTINC>> item5 in dictionary2)
			{
				Plugin.Log.LogDebug((object)$"  Station #{item5.Key}:");
				foreach (KeyValuePair<int, CNTINC> item6 in item5.Value)
				{
					string arg4 = LDB.ItemName(item6.Key);
					Plugin.Log.LogDebug((object)$"    {item6.Value} {arg4}");
				}
			}
			Plugin.Log.LogDebug((object)$"Time (in ticks): {observedCycleLength}");
			Plugin.Log.LogDebug((object)$"Time (in seconds): {(float)observedCycleLength / 60f}");
			analysedRecipe = new BlackboxRecipe
			{
				idleEnergyPerTick = num,
				workingEnergyPerTick = num3 / observedCycleLength,
				timeSpend = observedCycleLength,
				produces = dictionary3,
				consumes = dictionary4,
				inputs = dictionary,
				outputs = dictionary2
			};
		}

		public override void LogPowerConsumer()
		{
			Span<long> span = MemoryMarshal.Cast<int, long>(profilingTsData.LevelEntryOffset(0, profilingTick).Slice(0, pcSize));
			for (int i = 0; i < pcIds.Count; i++)
			{
				ref PowerConsumerComponent reference = ref simulationFactory.powerSystem.consumerPool[pcIds[i]];
				span[0] += reference.requiredEnergy;
			}
		}

		public override bool ShouldInterceptAssembler(FactorySystem factorySystem, int assemblerId)
		{
			if (factorySystem == simulationFactory.factorySystem)
			{
				return assemblerIds.Contains(assemblerId);
			}
			return false;
		}

		public override bool ShouldInterceptLab(FactorySystem factorySystem, int labId)
		{
			if (factorySystem == simulationFactory.factorySystem)
			{
				return labIds.Contains(labId);
			}
			return false;
		}

		public override bool ShouldInterceptSpraycoater(CargoTraffic cargoTraffic, int spraycoaterId)
		{
			if (cargoTraffic == simulationFactory.cargoTraffic)
			{
				return spraycoaterIds.Contains(spraycoaterId);
			}
			return false;
		}

		public override bool ShouldInterceptFractionator(FactorySystem factorySystem, int fractionatorId)
		{
			if (factorySystem == simulationFactory.factorySystem)
			{
				return fractionatorIds.Contains(fractionatorId);
			}
			return false;
		}

		public override void AdjustStationStorageCount()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			StationComponent[] stationPool = simulationFactory.transport.stationPool;
			for (int i = 0; i < stationStorages.Length; i++)
			{
				ref StationStorageData reference = ref stationStorages[i];
				StationComponent obj = stationPool[reference.stationId];
				int[] needs = obj.needs;
				ref StationStore reference2 = ref obj.storage[reference.storageIdx];
				int count = reference2.count;
				int max = reference2.max;
				int inc = reference2.inc;
				switch (phase)
				{
				case BenchmarkPhase.SpraySaturation:
				case BenchmarkPhase.SelfSpraySaturation:
					if ((int)reference.effectiveLogic == 2)
					{
						int num2 = (reference.isSpray ? (max / 2) : 0);
						inc = 0;
						count = num2;
					}
					needs[reference.storageIdx] = 0;
					break;
				case BenchmarkPhase.ItemSaturation:
					if ((int)reference.effectiveLogic == 2)
					{
						int num3 = max / 2;
						inc = 0;
						count = num3;
					}
					needs[reference.storageIdx] = 0;
					break;
				case BenchmarkPhase.Benchmarking:
				case BenchmarkPhase.Averaging:
					if ((int)reference.effectiveLogic == 2)
					{
						int num = max / 2;
						inc = 0;
						count = num;
					}
					needs[reference.storageIdx] = reference2.itemId;
					break;
				}
				reference2.count = count;
				reference2.inc = inc;
			}
		}

		public override void LogStationEntryBefore()
		{
			LogStationEntryExit(StationEntryExitRecordAction.EntryBefore);
		}

		public override void LogStationEntryAfter()
		{
			LogStationEntryExit(StationEntryExitRecordAction.EntryAfter);
		}

		public override void LogStationExitBefore()
		{
			LogStationEntryExit(StationEntryExitRecordAction.ExitBefore);
		}

		public override void LogStationExitAfter()
		{
			LogStationEntryExit(StationEntryExitRecordAction.ExitAfter);
		}

		private void LogStationEntryExit(StationEntryExitRecordAction recordAction)
		{
			Span<StationEntryExit> span = MemoryMarshal.Cast<int, StationEntryExit>(profilingTsData.LevelEntryOffset(0, profilingTick).Slice(stationOffset, stationSize));
			StationComponent[] stationPool = simulationFactory.transport.stationPool;
			for (int i = 0; i < stationStorages.Length; i++)
			{
				ref StationStorageData reference = ref stationStorages[i];
				ref StationStore reference2 = ref stationPool[reference.stationId].storage[reference.storageIdx];
				ref StationEntryExit reference3 = ref span[i];
				switch (recordAction)
				{
				case StationEntryExitRecordAction.EntryBefore:
					reference3.EntryCount = reference2.count;
					reference3.EntryInc = reference2.inc;
					break;
				case StationEntryExitRecordAction.EntryAfter:
					reference3.EntryCount = reference2.count - reference3.EntryCount;
					reference3.EntryInc = reference2.inc - reference3.EntryInc;
					break;
				case StationEntryExitRecordAction.ExitBefore:
					reference3.ExitCount = reference2.count;
					reference3.ExitInc = reference2.inc;
					break;
				case StationEntryExitRecordAction.ExitAfter:
					reference3.ExitCount -= reference2.count;
					reference3.ExitInc -= reference2.inc;
					break;
				}
			}
		}

		public override void DoInserterAdaptiveStacking()
		{
			if (adaptiveStacking || forceNoStacking)
			{
				for (int i = 0; i < inserterIds.Count; i++)
				{
					PlanetFactorySimulation.DoAdaptiveStacking(ref simulationFactory.factorySystem.inserterPool[inserterIds[i]], simulationFactory, forceNoStacking);
				}
			}
		}
	}
	public abstract class BlackboxBenchmarkBase : BlackboxAnalysis
	{
		public readonly int[] productRegister = new int[12000];

		public readonly int[] consumeRegister = new int[12000];

		protected BlackboxBenchmarkBase(Blackbox blackbox)
			: base(blackbox)
		{
		}

		public void BeginGameTick()
		{
			Array.Clear(productRegister, 0, 12000);
			Array.Clear(consumeRegister, 0, 12000);
		}

		public virtual void EndGameTick()
		{
		}

		public virtual void LogPowerConsumer()
		{
		}

		public virtual void AdjustStationStorageCount()
		{
		}

		public virtual void LogStationEntryBefore()
		{
		}

		public virtual void LogStationEntryAfter()
		{
		}

		public virtual void LogStationExitBefore()
		{
		}

		public virtual void LogStationExitAfter()
		{
		}

		public virtual void DoInserterAdaptiveStacking()
		{
		}

		public virtual bool ShouldInterceptAssembler(FactorySystem factorySystem, int assemblerId)
		{
			return false;
		}

		public virtual bool ShouldInterceptLab(FactorySystem factorySystem, int labId)
		{
			return false;
		}

		public virtual bool ShouldInterceptSpraycoater(CargoTraffic cargoTraffic, int spraycoaterId)
		{
			return false;
		}

		public virtual bool ShouldInterceptFractionator(FactorySystem factorySystem, int fractionatorId)
		{
			return false;
		}
	}
	public class BlackboxGatewayMethods
	{
		private static List<BlackboxBenchmarkBase> benchmarks = new List<BlackboxBenchmarkBase>();

		private static readonly Action<BlackboxBenchmarkBase> actionAfterPowerConsumerComponents = delegate(BlackboxBenchmarkBase b)
		{
			b.LogPowerConsumer();
		};

		private static readonly Action<BlackboxBenchmarkBase> actionBeforeStationBeltInput = delegate(BlackboxBenchmarkBase b)
		{
			b.AdjustStationStorageCount();
			b.LogStationEntryBefore();
		};

		private static readonly Action<BlackboxBenchmarkBase> actionAfterStationBeltInput = delegate(BlackboxBenchmarkBase b)
		{
			b.LogStationEntryAfter();
		};

		private static readonly Action<BlackboxBenchmarkBase> actionBeforeStationBeltOutput = delegate(BlackboxBenchmarkBase b)
		{
			b.AdjustStationStorageCount();
			b.LogStationExitBefore();
		};

		private static readonly Action<BlackboxBenchmarkBase> actionAfterStationBeltOutput = delegate(BlackboxBenchmarkBase b)
		{
			b.LogStationExitAfter();
			b.DoInserterAdaptiveStacking();
		};

		public static void GameTick_AfterPowerConsumerComponents(PlanetFactory factory)
		{
			DoForRelevantBenchmarks(factory, actionAfterPowerConsumerComponents);
		}

		public static void GameTick_BeforeStationBeltInput(PlanetFactory factory)
		{
			DoForRelevantBenchmarks(factory, actionBeforeStationBeltInput);
		}

		public static void GameTick_AfterStationBeltInput(PlanetFactory factory)
		{
			DoForRelevantBenchmarks(factory, actionAfterStationBeltInput);
		}

		public static void GameTick_BeforeStationBeltOutput(PlanetFactory factory)
		{
			DoForRelevantBenchmarks(factory, actionBeforeStationBeltOutput);
		}

		public static void GameTick_AfterStationBeltOutput(PlanetFactory factory)
		{
			DoForRelevantBenchmarks(factory, actionAfterStationBeltOutput);
		}

		public static void DoForRelevantBenchmarks(PlanetFactory factory, Action<BlackboxBenchmarkBase> action)
		{
			if (DSPGame.IsMenuDemo)
			{
				return;
			}
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis)
				{
					if (!benchmark.factoryRef.TryGetTarget(out var target))
					{
						Plugin.Log.LogError((object)"PlanetFactory instance pulled out from under BlackboxBenchmark in DoForRelevantBenchmarks");
					}
					else if (target == factory)
					{
						action(benchmark);
					}
				}
			}
		}

		public static void GameTick_Begin()
		{
			benchmarks = (from x in BlackboxManager.Instance.blackboxes
				where x.Status == BlackboxStatus.InAnalysis && !x.analyseInBackground && x.Analysis is BlackboxBenchmarkBase
				select x.Analysis as BlackboxBenchmarkBase).ToList();
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				benchmark.BeginGameTick();
			}
		}

		public static void GameTick_End()
		{
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis)
				{
					benchmark.EndGameTick();
				}
			}
		}

		public static uint InterceptAssemblerInternalUpdate(FactorySystem factorySystem, ref AssemblerComponent assembler, float power, int[] productRegister, int[] consumeRegister)
		{
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis && benchmark.ShouldInterceptAssembler(factorySystem, assembler.id))
				{
					return (!PlanetFactorySimulation.IsAssemblerStacking(ref assembler)) ? ((AssemblerComponent)(ref assembler)).InternalUpdate(1f, benchmark.productRegister, benchmark.consumeRegister) : 0u;
				}
			}
			return ((AssemblerComponent)(ref assembler)).InternalUpdate(power, productRegister, consumeRegister);
		}

		public static uint InterceptFractionatorInternalUpdate(FactorySystem factorySystem, int fractionatorId, float power, SignData[] entitySignPool, int[] productRegister, int[] consumeRegister)
		{
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis && benchmark.ShouldInterceptFractionator(factorySystem, fractionatorId))
				{
					return ((FractionatorComponent)(ref factorySystem.fractionatorPool[fractionatorId])).InternalUpdate(factorySystem.factory, 1f, entitySignPool, benchmark.productRegister, benchmark.consumeRegister);
				}
			}
			return ((FractionatorComponent)(ref factorySystem.fractionatorPool[fractionatorId])).InternalUpdate(factorySystem.factory, power, entitySignPool, productRegister, consumeRegister);
		}

		public static uint InterceptLabInternalUpdateAssemble(FactorySystem factorySystem, int labId, float power, int[] productRegister, int[] consumeRegister)
		{
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis && benchmark.ShouldInterceptLab(factorySystem, labId))
				{
					return ((LabComponent)(ref factorySystem.labPool[labId])).InternalUpdateAssemble(1f, benchmark.productRegister, benchmark.consumeRegister);
				}
			}
			return ((LabComponent)(ref factorySystem.labPool[labId])).InternalUpdateAssemble(power, productRegister, consumeRegister);
		}

		public static void InterceptSpraycoaterInternalUpdate(CargoTraffic cargoTraffic, int spraycoaterId, AnimData[] animPool, int[] consumeRegister)
		{
			foreach (BlackboxBenchmarkBase benchmark in benchmarks)
			{
				if (benchmark.blackbox.Status == BlackboxStatus.InAnalysis && benchmark.ShouldInterceptSpraycoater(cargoTraffic, spraycoaterId))
				{
					((SpraycoaterComponent)(ref cargoTraffic.spraycoaterPool[spraycoaterId])).InternalUpdate(cargoTraffic, animPool, benchmark.consumeRegister);
					return;
				}
			}
			((SpraycoaterComponent)(ref cargoTraffic.spraycoaterPool[spraycoaterId])).InternalUpdate(cargoTraffic, animPool, consumeRegister);
		}
	}
	[HarmonyPatch]
	internal class BlackboxBenchmarkPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(FactorySystem), "GameTickBeforePower")]
		public static void FactorySystem__GameTickBeforePower(FactorySystem __instance)
		{
			BlackboxGatewayMethods.GameTick_AfterPowerConsumerComponents(__instance.factory);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MultithreadSystem), "PreparePowerSystemFactoryData")]
		public static void MultithreadSystem__PreparePowerSystemFactoryData(PlanetFactory[] _factories)
		{
			for (int i = 0; i < _factories.Length; i++)
			{
				BlackboxGatewayMethods.GameTick_AfterPowerConsumerComponents(_factories[i]);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetTransport), "GameTick_InputFromBelt")]
		public static void PlanetTransport__GameTick_InputFromBeltPrefix(PlanetTransport __instance)
		{
			BlackboxGatewayMethods.GameTick_BeforeStationBeltInput(__instance.factory);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlanetTransport), "GameTick_InputFromBelt")]
		public static void PlanetTransport__GameTick_InputFromBeltPostfix(PlanetTransport __instance)
		{
			BlackboxGatewayMethods.GameTick_AfterStationBeltInput(__instance.factory);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlanetTransport), "GameTick_OutputToBelt")]
		public static void PlanetTransport__GameTick_OutputToBeltPrefix(PlanetTransport __instance)
		{
			BlackboxGatewayMethods.GameTick_BeforeStationBeltOutput(__instance.factory);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlanetTransport), "GameTick_OutputToBelt")]
		public static void PlanetTransport__GameTick_OutputToBeltPostfix(PlanetTransport __instance)
		{
			BlackboxGatewayMethods.GameTick_AfterStationBeltOutput(__instance.factory);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameStatData), "PrepareTick")]
		public static void GameStatData_PrepareTick()
		{
			BlackboxGatewayMethods.GameTick_Begin();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameStatData), "GameTick")]
		public static void GameStatData__GameTick()
		{
			BlackboxGatewayMethods.GameTick_End();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(FactorySystem), "GameTick", new Type[]
		{
			typeof(long),
			typeof(bool)
		})]
		[HarmonyPatch(typeof(FactorySystem), "GameTick", new Type[]
		{
			typeof(long),
			typeof(bool),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static IEnumerable<CodeInstruction> InterceptAssemblerInternalUpdatePatch(IEnumerable<CodeInstruction> code, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(code, generator);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, AccessTools.Method(typeof(AssemblerComponent), "InternalUpdate", (Type[])null, (Type[])null))), (string)null)
			});
			val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			});
			val.Advance(4);
			val.SetOperandAndAdvance((object)AccessTools.Method(typeof(BlackboxGatewayMethods), "InterceptAssemblerInternalUpdate", (Type[])null, (Type[])null));
			return val.InstructionEnumeration();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(FactorySystem), "GameTick", new Type[]
		{
			typeof(long),
			typeof(bool)
		})]
		[HarmonyPatch(typeof(FactorySystem), "GameTick", new Type[]
		{
			typeof(long),
			typeof(bool),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static IEnumerable<CodeInstruction> InterceptFractionatorInternalUpdatePatch(IEnumerable<CodeInstruction> code, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(code, generator);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[11]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.LoadsField(ci, AccessTools.Field(typeof(FactorySystem), "fractionatorPool"), false)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldelema, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.LoadsField(ci, AccessTools.Field(typeof(FactorySystem), "factory"), false)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, AccessTools.Method(typeof(FractionatorComponent), "InternalUpdate", (Type[])null, (Type[])null))), (string)null)
			});
			val.Advance(1);
			val.RemoveInstruction();
			val.Advance(1);
			val.RemoveInstruction();
			val.RemoveInstruction();
			val.RemoveInstruction();
			val.Advance(4);
			val.SetOperandAndAdvance((object)AccessTools.Method(typeof(BlackboxGatewayMethods), "InterceptFractionatorInternalUpdate", (Type[])null, (Type[])null));
			return val.InstructionEnumeration();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(FactorySystem), "GameTickLabProduceMode", new Type[]
		{
			typeof(long),
			typeof(bool)
		})]
		[HarmonyPatch(typeof(FactorySystem), "GameTickLabProduceMode", new Type[]
		{
			typeof(long),
			typeof(bool),
			typeof(int),
			typeof(int),
			typeof(int)
		})]
		private static IEnumerable<CodeInstruction> InterceptLabInternalUpdateAssemblePatch(IEnumerable<CodeInstruction> code, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(code, generator);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[8]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.LoadsField(ci, AccessTools.Field(typeof(FactorySystem), "labPool"), false)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldelema, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, AccessTools.Method(typeof(LabComponent), "InternalUpdateAssemble", (Type[])null, (Type[])null))), (string)null)
			});
			val.Advance(1);
			val.RemoveInstruction();
			val.Advance(1);
			val.RemoveInstruction();
			val.Advance(3);
			val.SetOperandAndAdvance((object)AccessTools.Method(typeof(BlackboxGatewayMethods), "InterceptLabInternalUpdateAssemble", (Type[])null, (Type[])null));
			return val.InstructionEnumeration();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(CargoTraffic), "SpraycoaterGameTick")]
		private static IEnumerable<CodeInstruction> InterceptSpraycoaterInternalUpdatePatch(IEnumerable<CodeInstruction> code, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(code, generator);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[8]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.LoadsField(ci, AccessTools.Field(typeof(CargoTraffic), "spraycoaterPool"), false)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldelema, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdarg(ci, (int?)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.IsLdloc(ci, (LocalBuilder)null)), (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, AccessTools.Method(typeof(SpraycoaterComponent), "InternalUpdate", (Type[])null, (Type[])null))), (string)null)
			});
			val.Advance(1);
			val.RemoveInstruction();
			val.Advance(1);
			val.RemoveInstruction();
			val.RemoveInstruction();
			val.Advance(2);
			val.SetOperandAndAdvance((object)AccessTools.Method(typeof(BlackboxGatewayMethods), "InterceptSpraycoaterInternalUpdate", (Type[])null, (Type[])null));
			return val.InstructionEnumeration();
		}
	}
	public class BlackboxFingerprint
	{
		private BlackboxSelection selection;

		private BlackboxFingerprint(BlackboxSelection selection)
		{
			this.selection = selection;
		}

		public static BlackboxFingerprint CreateFrom(BlackboxSelection selection)
		{
			return new BlackboxFingerprint(selection);
		}

		public override bool Equals(object obj)
		{
			BlackboxFingerprint blackboxFingerprint = obj as BlackboxFingerprint;
			if (obj == null)
			{
				return false;
			}
			if (selection.factoryIndex == blackboxFingerprint.selection.factoryIndex && selection.entityIds.SetEquals((IEnumerable<int>)blackboxFingerprint.selection.entityIds))
			{
				return true;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return ((object)selection.entityIds).GetHashCode();
		}
	}
	public class BlackboxHighlight
	{
		public int blackboxId;

		public List<int> warningIds = new List<int>();

		public const int blackboxSignalId = 60001;

		public int hoverBlackboxId;

		private List<BoxGizmo> hoverGizmos = new List<BoxGizmo>();

		private const int saveLogicVersion = 1;

		public void RequestHighlight(Blackbox blackbox)
		{
			if (blackbox == null)
			{
				ClearHighlight();
			}
			else if (blackboxId != blackbox.Id)
			{
				if (blackboxId > 0 && blackboxId != blackbox.Id)
				{
					ClearHighlight();
				}
				blackboxId = blackbox.Id;
				DoHighlight(blackbox);
			}
		}

		public void DoHighlight(Blackbox blackbox)
		{
			//IL_003c: 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)
			if (!blackbox.FactoryRef.TryGetTarget(out var target))
			{
				Plugin.Log.LogError((object)"PlanetFactory instance pulled out from under a blackbox simulation in DoHighlight");
				return;
			}
			ImmutableSortedSet<int> entityIds = blackbox.Selection.entityIds;
			WarningSystem warningSystem = GameMain.data.warningSystem;
			EntityData[] entityPool = target.entityPool;
			Enumerator<int> enumerator = entityIds.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					int current = enumerator.Current;
					ref EntityData reference = ref entityPool[current];
					if (reference.beltId <= 0 && reference.inserterId <= 0)
					{
						ref WarningData reference2 = ref warningSystem.NewWarningData(target.index, current, 60001);
						warningIds.Add(reference2.id);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public void StopHighlight()
		{
			WarningSystem warningSystem = GameMain.data.warningSystem;
			foreach (int warningId in warningIds)
			{
				warningSystem.RemoveWarningData(warningId);
			}
			warningIds.Clear();
		}

		public void ClearHighlight()
		{
			StopHighlight();
			blackboxId = 0;
		}

		public void SetHoverHighlight(Blackbox blackbox)
		{
			//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_00ea: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			int num = blackbox?.Id ?? 0;
			if (num == hoverBlackboxId)
			{
				DoHoverHighlightForBelts(blackbox);
				return;
			}
			hoverBlackboxId = num;
			if (blackbox == null)
			{
				foreach (BoxGizmo hoverGizmo in hoverGizmos)
				{
					if (Object.op_Implicit((Object)(object)hoverGizmo))
					{
						((GizmoBase)hoverGizmo).Close();
					}
				}
				hoverGizmos.Clear();
			}
			else
			{
				if (!blackbox.FactoryRef.TryGetTarget(out var target))
				{
					return;
				}
				EntityData[] entityPool = target.entityPool;
				Enumerator<int> enumerator2 = blackbox.Selection.entityIds.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						int current2 = enumerator2.Current;
						ref EntityData reference = ref entityPool[current2];
						if (reference.inserterId <= 0 && reference.beltId <= 0)
						{
							PrefabDesc prefabDesc = ((ProtoSet<ItemProto>)(object)LDB.items).Select((int)reference.protoId).prefabDesc;
							BoxGizmo val = BoxGizmo.Create(reference.pos, reference.rot, prefabDesc.selectCenter, prefabDesc.selectSize);
							val.multiplier = 1f;
							val.alphaMultiplier = prefabDesc.selectAlpha;
							val.fadeInScale = 1.3f;
							val.fadeInTime = 0.05f;
							val.fadeInFalloff = 0.5f;
							val.fadeOutScale = 1.3f;
							val.fadeOutTime = 0.05f;
							val.fadeOutFalloff = 0.5f;
							val.color = Color.white;
							((GizmoBase)val).Open();
							hoverGizmos.Add(val);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2).Dispose();
				}
				DoHoverHighlightForBelts(blackbox);
			}
		}

		private void DoHoverHighlightForBelts(Blackbox blackbox)
		{
			//IL_004b: 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)
			if (blackbox == null)
			{
				return;
			}
			if (!blackbox.FactoryRef.TryGetTarget(out var target))
			{
				Plugin.Log.LogError((object)"PlanetFactory instance pulled out from under a blackbox simulation in DoHoverHighlightForBelts");
				return;
			}
			EntityData[] entityPool = target.entityPool;
			CargoTraffic cargoTraffic = target.cargoTraffic;
			BeltComponent[] beltPool = cargoTraffic.beltPool;
			CargoPath[] pathPool = cargoTraffic.pathPool;
			Enumerator<int> enumerator = blackbox.Selection.entityIds.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					int current = enumerator.Current;
					int beltId = entityPool[current].beltId;
					if (beltId > 0)
					{
						ref BeltComponent reference = ref beltPool[beltId];
						ref CargoPath reference2 = ref pathPool[reference.segPathId];
						int id = reference.id;
						int id2 = reference2.id;
						reference.id = beltId;
						reference2.id = reference.segPathId;
						cargoTraffic.SetBeltState(beltId, 100);
						reference.id = id;
						reference2.id = id2;
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		public void PreserveVanillaSaveBefore()
		{
			StopHighlight();
		}

		public void PreserveVanillaSaveAfter()
		{
			if (blackboxId > 0)
			{
				Blackbox blackbox = BlackboxManager.Instance.blackboxes.Find((Blackbox x) => x.Id == blackboxId);
				if (blackbox != null)
				{
					DoHighlight(blackbox);
				}
			}
		}

		public void Export(BinaryWriter w)
		{
			w.Write(1);
			w.Write(blackboxId);
		}

		public void Import(BinaryReader r)
		{
			r.ReadInt32();
			blackboxId = r.ReadInt32();
			PreserveVanillaSaveAfter();
		}
	}
	public class BlackboxManager
	{
		private static int blackboxIdCounter = 1;

		public List<Blackbox> blackboxes = new List<Blackbox>();

		public List<Blackbox> blackboxesMarkedForRemoval = new List<Blackbox>();

		public AutoBlackbox autoBlackbox = new AutoBlackbox();

		public BlackboxHighlight highlight = new BlackboxHighlight();

		private const int saveLogicVersion = 1;

		public static BlackboxManager Instance { get; } = new BlackboxManager();


		public Blackbox CreateForSelection(BlackboxSelection selection)
		{
			lock (Instance)
			{
				int id = blackboxIdCounter;
				blackboxIdCounter++;
				Blackbox blackbox = new Blackbox(id, selection);
				blackboxes.Add(blackbox);
				return blackbox;
			}
		}

		public void MarkBlackboxForRemoval(Blackbox blackbox)
		{
			lock (Instance)
			{
				blackboxesMarkedForRemoval.Add(blackbox);
			}
		}

		public void RemoveMarkedBlackboxes()
		{
			lock (Instance)
			{
				foreach (Blackbox item in blackboxesMarkedForRemoval)
				{
					if (item.Id == highlight.blackboxId)
					{
						highlight.ClearHighlight();
					}
					item.Simulation?.EndBlackboxing();
					item.Analysis?.Free();
					blackboxes.Remove(item);
				}
				blackboxesMarkedForRemoval.Clear();
			}
		}

		public void PauseBlackboxBelts(PlanetFactory factory)
		{
			foreach (Blackbox blackbox in blackboxes)
			{
				BlackboxSimulation simulation = blackbox.Simulation;
				if (simulation != null && simulation.isBlackboxSimulating && blackbox.FactoryRef.TryGetTarget(out var target) && target == factory)
				{
					blackbox.Simulation.PauseBelts();
				}
			}
		}

		public void ResumeBlackboxBelts(PlanetFactory factory)
		{
			foreach (Blackbox blackbox in blackboxes)
			{
				BlackboxSimulation simulation = blackbox.Simulation;
				if (simulation != null && simulation.isBlackboxSimulating && blackbox.FactoryRef.TryGetTarget(out var target) && target == factory)
				{
					blackbox.Simulation.ResumeBelts();
				}
			}
		}

		public void SimulateBlackboxes()
		{
			foreach (Blackbox blackbox in blackboxes)
			{
				blackbox.Simulation?.Simulate();
			}
		}

		public void GameTick()
		{
			foreach (Blackbox blackbox in blackboxes)
			{
				blackbox.GameTick();
			}
			autoBlackbox.GameTick();
		}

		public void ClearAll()
		{
			lock (Instance)
			{
				foreach (Blackbox blackbox in blackboxes)
				{
					blackbox.Simulation?.EndBlackboxing();
					blackbox.Analysis?.Free();
				}
				blackboxes.Clear();
				blackboxesMarkedForRemoval.Clear();
				blackboxIdCounter = 1;
			}
			autoBlackbox.isActive = false;
			highlight.ClearHighlight();
		}

		public void PreserveVanillaSaveBefore()
		{
			RemoveMarkedBlackboxes();
			highlight.PreserveVanillaSaveBefore();
			for (int i = 0; i < blackboxes.Count; i++)
			{
				blackboxes[i].PreserveVanillaSaveBefore();
			}
		}

		public void PreserveVanillaSaveAfter()
		{
			highlight.PreserveVanillaSaveAfter();
			for (int i = 0; i < blackboxes.Count; i++)
			{
				blackboxes[i].PreserveVanillaSaveAfter();
			}
		}

		public void Export(BinaryWriter w)
		{
			w.Write(1);
			w.Write(blackboxIdCounter);
			w.Write(blackboxes.Count);
			for (int i = 0; i < blackboxes.Count; i++)
			{
				blackboxes[i].Export(w);
			}
			w.Write(blackboxesMarkedForRemoval.Count);
			for (int j = 0; j < blackboxesMarkedForRemoval.Count; j++)
			{
				w.Write(blackboxesMarkedForRemoval[j].Id);
			}
			autoBlackbox.Export(w);
			highlight.Export(w);
		}

		public void Import(BinaryReader r)
		{
			r.ReadInt32();
			blackboxIdCounter = r.ReadInt32();
			int num = r.ReadInt32();
			blackboxes.Clear();
			blackboxes.Capacity = num;
			for (int i = 0; i < num; i++)
			{
				blackboxes.Add(Blackbox.Import(r));
			}
			int num2 = r.ReadInt32();
			blackboxesMarkedForRemoval.Clear();
			blackboxesMarkedForRemoval.Capacity = num2;
			for (int j = 0; j < num2; j++)
			{
				int id = r.ReadInt32();
				Blackbox item = blackboxes.Find((Blackbox b) => b.Id == id);
				blackboxesMarkedForRemoval.Add(item);
			}
			autoBlackbox.Import(r);
			highlight.Import(r);
		}
	}
	internal class BlackboxPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameStatData), "GameTick")]
		public static void GameStatData__GameTick()
		{
			BlackboxManager.Instance.RemoveMarkedBlackboxes();
			BlackboxManager.Instance.GameTick();
			BlackboxManager.Instance.SimulateBlackboxes();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameData), "Destroy")]
		public static void GameData__Destroy()
		{
			BlackboxManager.Instance.ClearAll();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CargoTraffic), "CreateRenderingBatches")]
		public static void BeforeCreateRenderingBatches(CargoTraffic __instance)
		{
			BlackboxManager.Instance.PauseBlackboxBelts(__instance.factory);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CargoTraffic), "CreateRenderingBatches")]
		public static void AfterCreateRenderingBatches(CargoTraffic __instance)
		{
			BlackboxManager.Instance.ResumeBlackboxBelts(__instance.factory);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerAction_Build), "DoDismantleObject")]
		public static void BeforeDismantleObject(PlayerAction_Build __instance, int objId)
		{
			__instance.SetFactoryReferences();
			Blackbox blackbox = BlackboxUtils.QueryEntityForAssociatedBlackbox(__instance.factory, objId);
			if (blackbox != null)
			{
				BlackboxManager.Instance.MarkBlackboxForRemoval(blackbox);
				BlackboxManager.Instance.RemoveMarkedBlackboxes();
			}
		}
	}
	public struct CNT
	{
		public int count;

		public override string ToString()
		{
			return count.ToString();
		}
	}
	public struct CNTINC
	{
		public int count;

		public int inc;

		public override string ToString()
		{
			return $"({count}, {inc})";
		}

		public void Deconstruct(out int count, out int inc)
		{
			count = this.count;
			inc = this.inc;
		}
	}
	public class BlackboxRecipe
	{
		public long idleEnergyPerTick;

		public long workingEnergyPerTick;

		public int timeSpend;

		public Dictionary<int, Dictionary<int, CNT>> inputs;

		public Dictionary<int, Dictionary<int, CNTINC>> outputs;

		public Dictionary<int, int> produces;

		public Dictionary<int, int> consumes;

		private const int saveLogicVersion = 2;

		public void Export(BinaryWriter w)
		{
			w.Write(2);
			w.Write(idleEnergyPerTick);
			w.Write(workingEnergyPerTick);
			w.Write(timeSpend);
			w.Write(inputs.Count);
			foreach (KeyValuePair<int, Dictionary<int, CNT>> input in inputs)
			{
				w.Write(input.Key);
				Dictionary<int, CNT> value = input.Value;
				w.Write(value.Count);
				foreach (KeyValuePair<int, CNT> item in value)
				{
					w.Write(item.Key);
					w.Write(item.Value.count);
				}
			}
			w.Write(outputs.Count);
			foreach (KeyValuePair<int, Dictionary<int, CNTINC>> output in outputs)
			{
				w.Write(output.Key);
				Dictionary<int, CNTINC> value2 = output.Value;
				w.Write(value2.Count);
				foreach (KeyValuePair<int, CNTINC> item2 in value2)
				{
					w.Write(item2.Key);
					w.Write(item2.Value.count);
					w.Write(item2.Value.inc);
				}
			}
			w.Write(produces.Count);
			foreach (KeyValuePair<int, int> produce in produces)
			{
				w.Write(produce.Key);
				w.Write(produce.Value);
			}
			w.Write(consumes.Count);
			foreach (KeyValuePair<int, int> consume in consumes)
			{
				w.Write(consume.Key);
				w.Write(consume.Value);
			}
		}

		public static BlackboxRecipe Import(BinaryReader r)
		{
			int num = r.ReadInt32();
			BlackboxRecipe blackboxRecipe = new BlackboxRecipe();
			blackboxRecipe.idleEnergyPerTick = r.ReadInt64();
			blackboxRecipe.workingEnergyPerTick = r.ReadInt64();
			blackboxRecipe.timeSpend = r.ReadInt32();
			int num2 = r.ReadInt32();
			blackboxRecipe.inputs = new Dictionary<int, Dictionary<int, CNT>>();
			for (int i = 0; i < num2; i++)
			{
				int key = r.ReadInt32();
				int num3 = r.ReadInt32();
				Dictionary<int, CNT> dictionary = new Dictionary<int, CNT>();
				for (int j = 0; j < num3; j++)
				{
					int key2 = r.ReadInt32();
					int count = r.ReadInt32();
					dictionary.Add(key2, new CNT
					{
						count = count
					});
				}
				blackboxRecipe.inputs.Add(key, dictionary);
			}
			int num4 = r.ReadInt32();
			blackboxRecipe.outputs = new Dictionary<int, Dictionary<int, CNTINC>>();
			for (int k = 0; k < num4; k++)
			{
				int key3 = r.ReadInt32();
				int num5 = r.ReadInt32();
				Dictionary<int, CNTINC> dictionary2 = new Dictionary<int, CNTINC>();
				for (int l = 0; l < num5; l++)
				{
					int key4 = r.ReadInt32();
					int count2 = r.ReadInt32();
					int inc = 0;
					if (num >= 2)
					{
						inc = r.ReadInt32();
					}
					dictionary2.Add(key4, new CNTINC
					{
						count = count2,
						inc = inc
					});
				}
				blackboxRecipe.outputs.Add(key3, dictionary2);
			}
			int num6 = r.ReadInt32();
			blackboxRecipe.produces = new Dictionary<int, int>();
			for (int m = 0; m < num6; m++)
			{
				int key5 = r.ReadInt32();
				int value = r.ReadInt32();
				blackboxRecipe.produces.Add(key5, value);
			}
			int num7 = r.ReadInt32();
			blackboxRecipe.consumes = new Dictionary<int, int>();
			for (int n = 0; n < num7; n++)
			{
				int key6 = r.ReadInt32();
				int value2 = r.ReadInt32();
				blackboxRecipe.consumes.Add(key6, value2);
			}
			return blackboxRecipe;
		}
	}
	public class BlackboxSelection
	{
		public readonly int factoryIndex;

		public readonly WeakReference<PlanetFactory> factoryRef;

		public readonly ImmutableSortedSet<int> entityIds;

		public readonly ImmutableSortedSet<int> pcIds;

		public readonly ImmutableSortedSet<int> assemblerIds;

		public readonly ImmutableSortedSet<int> labIds;

		public readonly ImmutableSortedSet<int> inserterIds;

		public readonly ImmutableSortedSet<int> stationIds;

		public readonly ImmutableSortedSet<int> cargoPathIds;

		public readonly ImmutableSortedSet<int> splitterIds;

		public readonly ImmutableSortedSet<int> pilerIds;

		public readonly ImmutableSortedSet<int> spraycoaterIds;

		public readonly ImmutableSortedSet<int> monitorIds;

		public readonly ImmutableSortedSet<int> fractionatorIds;

		public readonly ImmutableSortedSet<int> itemIds;

		private const int saveLogicVersion = 1;

		private BlackboxSelection(PlanetFactory factory, ImmutableSortedSet<int> entityIds, ImmutableSortedSet<int> pcIds, ImmutableSortedSet<int> assemblerIds, ImmutableSortedSet<int> labIds, ImmutableSortedSet<int> inserterIds, ImmutableSortedSet<int> stationIds, ImmutableSortedSet<int> cargoPathIds, ImmutableSortedSet<int> splitterIds, ImmutableSortedSet<int> pilerIds, ImmutableSortedSet<int> spraycoaterIds, ImmutableSortedSet<int> monitorIds, ImmutableSortedSet<int> fractionatorIds, ImmutableSortedSet<int> itemIds)
		{
			factoryIndex = factory.index;
			factoryRef = new WeakReference<PlanetFactory>(factory);
			this.entityIds = entityIds;
			this.pcIds = pcIds;
			this.assemblerIds = assemblerIds;
			this.labIds = labIds;
			this.inserterIds = inserterIds;
			this.stationIds = stationIds;
			this.cargoPathIds = cargoPathIds;
			this.splitterIds = splitterIds;
			this.pilerIds = pilerIds;
			this.spraycoaterIds = spraycoaterIds;
			this.monitorIds = monitorIds;
			this.fractionatorIds = fractionatorIds;
			this.itemIds = itemIds;
		}

		public static BlackboxSelection CreateFrom(PlanetFactory factory, ICollection<int> entityIds)
		{
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_00e6: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			List<int> list3 = new List<int>();
			List<int> list4 = new List<int>();
			List<int> list5 = new List<int>();
			HashSet<int> hashSet = new HashSet<int>();
			HashSet<int> hashSet2 = new HashSet<int>();
			List<int> list6 = new List<int>();
			List<int> list7 = new List<int>();
			Li