using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using AIGraph;
using AK;
using Agents;
using AmorLib.Dependencies;
using AmorLib.Networking.StateReplicators;
using AmorLib.Utils;
using AmorLib.Utils.JsonElementConverters;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using ChainedPuzzles;
using Enemies;
using ExtraObjectiveSetup.BaseClasses;
using ExtraObjectiveSetup.BaseClasses.CustomTerminalDefinition;
using ExtraObjectiveSetup.Expedition;
using ExtraObjectiveSetup.Expedition.Gears;
using ExtraObjectiveSetup.Expedition.IndividualGeneratorGroup;
using ExtraObjectiveSetup.ExtendedWardenEvents;
using ExtraObjectiveSetup.Instances;
using ExtraObjectiveSetup.Instances.ChainedPuzzle;
using ExtraObjectiveSetup.JSON;
using ExtraObjectiveSetup.Objectives.ActivateSmallHSU;
using ExtraObjectiveSetup.Objectives.GeneratorCluster;
using ExtraObjectiveSetup.Objectives.IndividualGenerator;
using ExtraObjectiveSetup.Objectives.ObjectiveCounter;
using ExtraObjectiveSetup.Objectives.TerminalUplink;
using ExtraObjectiveSetup.Tweaks.BossEvents;
using ExtraObjectiveSetup.Tweaks.Scout;
using ExtraObjectiveSetup.Tweaks.TerminalPosition;
using ExtraObjectiveSetup.Tweaks.TerminalTweak;
using ExtraObjectiveSetup.Utils;
using GTFO.API;
using GTFO.API.Extensions;
using GTFO.API.Utilities;
using GameData;
using Gear;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Localization;
using MTFO.API;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using StateMachines;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Inas07.ExtraObjectiveSetup")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+4c41a207dfaa6ad7f7c49b30d46675feaa6c9188")]
[assembly: AssemblyProduct("Inas07.ExtraObjectiveSetup")]
[assembly: AssemblyTitle("Inas07.ExtraObjectiveSetup")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 ExtraObjectiveSetup
{
	public static class EOSNetworking
	{
		public const uint INVALID_ID = 0u;

		public const uint FOREVER_REPLICATOR_ID_START = 1000u;

		public const uint REPLICATOR_ID_START = 10000u;

		private static uint currentForeverID;

		private static uint currentID;

		private static HashSet<uint> foreverUsedIDs;

		private static HashSet<uint> usedIDs;

		public static uint AllotReplicatorID()
		{
			while (currentID >= 10000 && usedIDs.Contains(currentID))
			{
				currentID++;
			}
			if (currentID < 10000)
			{
				EOSLogger.Error("Replicator ID depleted. How?");
				return 0u;
			}
			uint num = currentID;
			usedIDs.Add(num);
			currentID++;
			return num;
		}

		public static bool TryAllotID(uint id)
		{
			return usedIDs.Add(id);
		}

		public static uint AllotForeverReplicatorID()
		{
			while (currentForeverID < 10000 && foreverUsedIDs.Contains(currentForeverID))
			{
				currentForeverID++;
			}
			if (currentForeverID >= 10000)
			{
				EOSLogger.Error("Forever Replicator ID depleted.");
				return 0u;
			}
			uint num = currentForeverID;
			foreverUsedIDs.Add(num);
			currentForeverID++;
			return num;
		}

		private static void Clear()
		{
			usedIDs.Clear();
			currentID = 10000u;
		}

		public static void ClearForever()
		{
			foreverUsedIDs.Clear();
			currentForeverID = 1000u;
		}

		static EOSNetworking()
		{
			currentForeverID = 1000u;
			currentID = 10000u;
			foreverUsedIDs = new HashSet<uint>();
			usedIDs = new HashSet<uint>();
			LevelAPI.OnBuildStart += Clear;
			LevelAPI.OnLevelCleanup += Clear;
		}
	}
	public sealed class BatchBuildManager
	{
		private Dictionary<BatchName, Action> OnBatchStart = new Dictionary<BatchName, Action>();

		private Dictionary<BatchName, Action> OnBatchDone = new Dictionary<BatchName, Action>();

		public static BatchBuildManager Current { get; private set; }

		public void Init()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (OnBatchStart.Count < 1)
			{
				foreach (object value in Enum.GetValues(typeof(BatchName)))
				{
					OnBatchStart[(BatchName)value] = null;
				}
			}
			if (OnBatchDone.Count >= 1)
			{
				return;
			}
			foreach (object value2 in Enum.GetValues(typeof(BatchName)))
			{
				OnBatchDone[(BatchName)value2] = null;
			}
		}

		public void Add_OnBatchDone(BatchName batchName, Action action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<BatchName, Action> onBatchDone = OnBatchDone;
			onBatchDone[batchName] = (Action)Delegate.Combine(onBatchDone[batchName], action);
		}

		public void Remove_OnBatchDone(BatchName batchName, Action action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<BatchName, Action> onBatchDone = OnBatchDone;
			onBatchDone[batchName] = (Action)Delegate.Remove(onBatchDone[batchName], action);
		}

		public Action Get_OnBatchDone(BatchName batchName)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return OnBatchDone[batchName];
		}

		public void Add_OnBatchStart(BatchName batchName, Action action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<BatchName, Action> onBatchStart = OnBatchStart;
			onBatchStart[batchName] = (Action)Delegate.Combine(onBatchStart[batchName], action);
		}

		public void Remove_OnBatchStart(BatchName batchName, Action action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<BatchName, Action> onBatchStart = OnBatchStart;
			onBatchStart[batchName] = (Action)Delegate.Remove(onBatchStart[batchName], action);
		}

		public Action Get_OnBatchStart(BatchName batchName)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return OnBatchStart[batchName];
		}

		private BatchBuildManager()
		{
		}

		static BatchBuildManager()
		{
			Current = new BatchBuildManager();
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Inas.ExtraObjectiveSetup", "ExtraObjectiveSetup", "1.8.0")]
	[BepInIncompatibility("Amor.ExcellentObjectiveSetup")]
	public class EntryPoint : BasePlugin
	{
		public const string AUTHOR = "Inas";

		public const string PLUGIN_NAME = "ExtraObjectiveSetup";

		public const string VERSION = "1.8.0";

		private Harmony m_Harmony;

		public override void Load()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			m_Harmony = new Harmony("ExtraObjectiveSetup");
			m_Harmony.PatchAll();
			SetupManagers();
		}

		private void SetupManagers()
		{
			LocalPlayer.Init();
			BatchBuildManager.Current.Init();
			SerialGeneratorManager.Init();
			IndividualGeneratorObjectiveManager.Current.Init();
			GeneratorClusterObjectiveManager.Current.Init();
			HSUActivatorObjectiveManager.Current.Init();
			UplinkObjectiveManager.Current.Init();
			TerminalPositionOverrideManager.Current.Init();
			ScoutScreamEventManager.Current.Init();
			BossDeathEventManager.Current.Init();
			ExpeditionDefinitionManager.Current.Init();
			ExpeditionGearManager.Current.Init();
			ExpeditionIGGroupManager.Current.Init();
			GeneratorClusterInstanceManager.Current.Init();
			HSUActivatorInstanceManager.Current.Init();
			PowerGeneratorInstanceManager.Current.Init();
			TerminalInstanceManager.Current.Init();
			ObjectiveCounterManager.Current.Init();
		}
	}
}
namespace ExtraObjectiveSetup.Utils
{
	public static class EOSTerminalUtils
	{
		public static List<LG_ComputerTerminal> FindTerminal(eDimensionIndex dimensionIndex, LG_LayerType layerType, eLocalZoneIndex localIndex, Predicate<LG_ComputerTerminal> predicate)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			LG_Zone val = default(LG_Zone);
			if (!Builder.CurrentFloor.TryGetZoneByLocalIndex(dimensionIndex, layerType, localIndex, ref val) || (Object)(object)val == (Object)null)
			{
				EOSLogger.Error($"SelectTerminal: Could NOT find zone {(dimensionIndex, layerType, localIndex)}");
				return null;
			}
			if (val.TerminalsSpawnedInZone.Count <= 0)
			{
				EOSLogger.Error($"SelectTerminal: Could not find any terminals in zone {(dimensionIndex, layerType, localIndex)}");
				return null;
			}
			List<LG_ComputerTerminal> list = new List<LG_ComputerTerminal>();
			Enumerator<LG_ComputerTerminal> enumerator = val.TerminalsSpawnedInZone.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LG_ComputerTerminal current = enumerator.Current;
				if (predicate != null)
				{
					if (predicate(current))
					{
						list.Add(current);
					}
				}
				else
				{
					list.Add(current);
				}
			}
			return list;
		}

		public static TerminalLogFileData GetLocalLog(this LG_ComputerTerminal terminal, string logName)
		{
			Dictionary<string, TerminalLogFileData> localLogs = terminal.GetLocalLogs();
			logName = logName.ToUpperInvariant();
			return localLogs.ContainsKey(logName) ? localLogs[logName] : null;
		}

		public static void ResetInitialOutput(this LG_ComputerTerminal terminal)
		{
			terminal.m_command.ClearOutputQueueAndScreenBuffer();
			terminal.m_command.AddInitialTerminalOutput();
			if (terminal.IsPasswordProtected)
			{
				terminal.m_command.AddPasswordProtectedOutput((Il2CppStringArray)null);
			}
		}

		public static List<WardenObjectiveEventData> GetUniqueCommandEvents(this LG_ComputerTerminal terminal, string command)
		{
			List<WardenObjectiveEventData> result = new List<WardenObjectiveEventData>();
			if ((Object)(object)terminal.ConnectedReactor != (Object)null)
			{
				return result;
			}
			List<LG_ComputerTerminal> terminalsSpawnedInZone = terminal.SpawnNode.m_zone.TerminalsSpawnedInZone;
			int num = terminalsSpawnedInZone.IndexOf(terminal);
			AIG_CourseNode spawnNode = terminal.SpawnNode;
			ExpeditionZoneData val = ((spawnNode != null) ? spawnNode.m_zone.m_settings.m_zoneData : null) ?? null;
			if (val == null)
			{
				EOSLogger.Error("GetCommandEvents: Cannot find target zone data.");
				return result;
			}
			if (num < 0 || num >= val.TerminalPlacements.Count)
			{
				EOSLogger.Debug($"GetCommandEvents: TerminalDataIndex({num}), TargetZoneData.TerminalPlacements.Count == ({val.TerminalPlacements.Count}) - maybe a custom terminal, skipped");
				return result;
			}
			List<CustomTerminalCommand> uniqueCommands = val.TerminalPlacements[num].UniqueCommands;
			Enumerator<CustomTerminalCommand> enumerator = uniqueCommands.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CustomTerminalCommand current = enumerator.Current;
				if (current.Command.ToLower().Equals(command.ToLower()))
				{
					return current.CommandEvents.ToManaged<WardenObjectiveEventData>();
				}
			}
			EOSLogger.Error("GetCommandEvents: command '" + command + "' not found on " + terminal.ItemKey);
			return result;
		}

		public static LG_ComputerTerminal SelectPasswordTerminal(eDimensionIndex dimensionIndex, LG_LayerType layerType, eLocalZoneIndex localIndex, eSeedType seedType, int staticSeed = 1)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected I4, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			if ((int)seedType == 0)
			{
				EOSLogger.Error($"SelectTerminal: unsupported seed type {seedType}");
				return null;
			}
			List<LG_ComputerTerminal> list = FindTerminal(dimensionIndex, layerType, localIndex, (LG_ComputerTerminal x) => !x.HasPasswordPart);
			if (list == null)
			{
				EOSLogger.Error($"SelectTerminal: Could not find zone {(dimensionIndex, layerType, localIndex)}!");
				return null;
			}
			if (list.Count <= 0)
			{
				EOSLogger.Error($"SelectTerminal: Could not find any terminals without a password part in zone {(dimensionIndex, layerType, localIndex)}, putting the password on random (session) already used terminal.");
				LG_Zone val = default(LG_Zone);
				Builder.CurrentFloor.TryGetZoneByLocalIndex(dimensionIndex, layerType, localIndex, ref val);
				return val.TerminalsSpawnedInZone[Builder.SessionSeedRandom.Range(0, val.TerminalsSpawnedInZone.Count, "NO_TAG")];
			}
			switch (seedType - 1)
			{
			case 0:
				return list[Builder.SessionSeedRandom.Range(0, list.Count, "NO_TAG")];
			case 1:
				return list[Builder.BuildSeedRandom.Range(0, list.Count, "NO_TAG")];
			case 2:
				Random.InitState(staticSeed);
				return list[Random.Range(0, list.Count)];
			default:
				EOSLogger.Error("SelectTerminal: did not have a valid SeedType!!");
				return null;
			}
		}

		public static void BuildPassword(LG_ComputerTerminal terminal, TerminalPasswordData data)
		{
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Invalid comparison between Unknown and I4
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Expected O, but got Unknown
			//IL_058c: Expected O, but got Unknown
			if (!data.PasswordProtected)
			{
				return;
			}
			if (terminal.IsPasswordProtected)
			{
				EOSLogger.Error("EOSTerminalUtils.BuildPassword: " + terminal.PublicName + " is already password-protected!");
				return;
			}
			if (!data.GeneratePassword)
			{
				terminal.LockWithPassword(data.Password, new string[1] { data.PasswordHintText });
				return;
			}
			if (data.TerminalZoneSelectionDatas.Count <= 0)
			{
				EOSLogger.Error($"Tried to generate a password for terminal {terminal.PublicName} with no {typeof(TerminalZoneSelectionData).Name}!! This is not allowed.");
				return;
			}
			string codeWord = SerialGeneratorManager.GetCodeWord(data.PasswordWordLength);
			string passwordHintText = data.PasswordHintText;
			string text = "<b>[Forgot your password?]</b> Backup security key(s) located in logs on ";
			int num = data.PasswordPartCount;
			if (codeWord.Length % num != 0)
			{
				EOSLogger.Error($"Build() password.Length ({codeWord.Length}) not divisible by passwordParts ({num}). Defaulting to 1.");
				num = 1;
			}
			string[] array = ((num > 1) ? Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)StringUtils.SplitIntoChunksArray(codeWord, codeWord.Length / num)) : new string[1] { codeWord });
			string text2 = "";
			if (data.ShowPasswordPartPositions)
			{
				for (int i = 0; i < array[0].Length; i++)
				{
					text2 += "-";
				}
			}
			HashSet<LG_ComputerTerminal> hashSet = new HashSet<LG_ComputerTerminal>();
			LG_Zone val = default(LG_Zone);
			for (int j = 0; j < num; j++)
			{
				int index = j % data.TerminalZoneSelectionDatas.Count;
				List<CustomTerminalZoneSelectionData> list = data.TerminalZoneSelectionDatas[index];
				int index2 = Builder.SessionSeedRandom.Range(0, list.Count, "NO_TAG");
				CustomTerminalZoneSelectionData customTerminalZoneSelectionData = list[index2];
				LG_ComputerTerminal val2;
				if ((int)customTerminalZoneSelectionData.SeedType == 0)
				{
					if (!Builder.CurrentFloor.TryGetZoneByLocalIndex(customTerminalZoneSelectionData.DimensionIndex, customTerminalZoneSelectionData.LayerType, customTerminalZoneSelectionData.LocalIndex, ref val) || (Object)(object)val == (Object)null)
					{
						EOSLogger.Error($"BuildPassword: seedType {0} specified but cannot find zone {customTerminalZoneSelectionData.GlobalZoneIndexTuple()}");
					}
					if (val.TerminalsSpawnedInZone.Count <= 0)
					{
						EOSLogger.Error($"BuildPassword: seedType {0} specified but cannot find terminal zone {customTerminalZoneSelectionData.GlobalZoneIndexTuple()}");
					}
					val2 = val.TerminalsSpawnedInZone[customTerminalZoneSelectionData.TerminalIndex];
				}
				else
				{
					val2 = SelectPasswordTerminal(customTerminalZoneSelectionData.DimensionIndex, customTerminalZoneSelectionData.LayerType, customTerminalZoneSelectionData.LocalIndex, customTerminalZoneSelectionData.SeedType);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					EOSLogger.Error($"BuildPassword: CRITICAL ERROR, could not get a LG_ComputerTerminal for password part ({j + 1}/{num}) for {terminal.PublicName} backup log.");
					continue;
				}
				string text3 = "";
				string text4;
				if (data.ShowPasswordPartPositions)
				{
					for (int k = 0; k < j; k++)
					{
						text3 += text2;
					}
					text4 = text3 + array[j];
					for (int l = j; l < num - 1; l++)
					{
						text4 += text2;
					}
				}
				else
				{
					text4 = array[j];
				}
				string value = (data.ShowPasswordPartPositions ? $"0{j + 1}" : $"0{Builder.SessionSeedRandom.Range(0, 9, "NO_TAG")}");
				TerminalLogFileData val3 = new TerminalLogFileData
				{
					FileName = $"key{value}_{LG_TerminalPasswordLinkerJob.GetTerminalNumber(terminal)}{(val2.HasPasswordPart ? "_1" : "")}.LOG",
					FileContent = new LocalizedText
					{
						UntranslatedText = string.Format(Text.Get((num > 1) ? 1431221909u : 2260297836u), text4),
						Id = 0u
					}
				};
				val2.AddLocalLog(val3, true);
				if (!hashSet.Contains(val2))
				{
					if (j > 0)
					{
						text += ", ";
					}
					text = text + val2.PublicName + " in " + val2.SpawnNode.m_zone.AliasName;
				}
				hashSet.Add(val2);
				val2.HasPasswordPart = true;
			}
			string text5 = text + ".";
			if (data.ShowPasswordLength)
			{
				terminal.LockWithPassword(codeWord, new string[3]
				{
					passwordHintText,
					text5,
					"Char[" + codeWord.Length + "]"
				});
			}
			else
			{
				terminal.LockWithPassword(codeWord, new string[2] { passwordHintText, text5 });
			}
		}

		public static void AddUniqueCommand(LG_ComputerTerminal terminal, CustomCommand cmd)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			if (terminal.m_command.m_commandsPerString.ContainsKey(cmd.Command))
			{
				EOSLogger.Error("Duplicate command name: '" + cmd.Command + "', cannot add command");
				return;
			}
			TERM_Command val = default(TERM_Command);
			if (!terminal.m_command.TryGetUniqueCommandSlot(ref val))
			{
				EOSLogger.Error("Cannot get more unique command slot, max: 5");
				return;
			}
			terminal.m_command.AddCommand(val, cmd.Command, cmd.CommandDesc.ParseToLocalizedText(), cmd.SpecialCommandRule, ListExtensions.ToIl2Cpp<WardenObjectiveEventData>(cmd.CommandEvents), ListExtensions.ToIl2Cpp<TerminalOutput>(cmd.PostCommandOutputs.ConvertAll((CustomCommand.LocaleTerminalOutput x) => x.ToTerminalOutput())));
			for (int num = 0; num < cmd.CommandEvents.Count; num++)
			{
				WardenObjectiveEventData val2 = cmd.CommandEvents[num];
				if (val2.ChainPuzzle == 0)
				{
					continue;
				}
				ChainedPuzzleDataBlock block = GameDataBlockBase<ChainedPuzzleDataBlock>.GetBlock(val2.ChainPuzzle);
				if (block == null)
				{
					continue;
				}
				LG_Area val3;
				Transform val4;
				if (terminal.SpawnNode != null)
				{
					val3 = terminal.SpawnNode.m_area;
					val4 = terminal.m_wardenObjectiveSecurityScanAlign;
				}
				else
				{
					LG_WardenObjective_Reactor connectedReactor = terminal.ConnectedReactor;
					object obj;
					if (connectedReactor == null)
					{
						obj = null;
					}
					else
					{
						AIG_CourseNode spawnNode = connectedReactor.SpawnNode;
						obj = ((spawnNode != null) ? spawnNode.m_area : null);
					}
					if (obj == null)
					{
						obj = null;
					}
					val3 = (LG_Area)obj;
					LG_WardenObjective_Reactor connectedReactor2 = terminal.ConnectedReactor;
					val4 = ((connectedReactor2 != null) ? connectedReactor2.m_chainedPuzzleAlign : null) ?? null;
				}
				if ((Object)(object)val3 == (Object)null)
				{
					EOSLogger.Error("Terminal Source Area is not found! Cannot create chained puzzle for command " + cmd.Command + "!");
					continue;
				}
				ChainedPuzzleInstance val5 = ChainedPuzzleManager.CreatePuzzleInstance(block, val3, val4.position, val4, val2.UseStaticBioscanPoints);
				List<WardenObjectiveEventData> events = ListExtensions.ToIl2Cpp<WardenObjectiveEventData>(cmd.CommandEvents.GetRange(num, cmd.CommandEvents.Count - num));
				val5.OnPuzzleSolved += Action.op_Implicit((Action)delegate
				{
					WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(events, (eWardenObjectiveEventTrigger)0, true, 0f, (Il2CppStructArray<eWardenObjectiveEventType>)null);
				});
				terminal.SetChainPuzzleForCommand(val, num, val5);
			}
		}
	}
	public static class EOSUtils
	{
		public static List<T> ToManaged<T>(this List<T> il2cppList)
		{
			List<T> list = new List<T>();
			Enumerator<T> enumerator = il2cppList.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				list.Add(current);
			}
			return list;
		}

		public static void ResetProgress(this ChainedPuzzleInstance chainedPuzzle)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			if (chainedPuzzle.Data.DisableSurvivalWaveOnComplete)
			{
				chainedPuzzle.m_sound = new CellSoundPlayer(chainedPuzzle.m_parent.position);
			}
			foreach (iChainedPuzzleCore item in (Il2CppArrayBase<iChainedPuzzleCore>)(object)chainedPuzzle.m_chainedPuzzleCores)
			{
				ResetChild(item);
			}
			if (SNet.IsMaster)
			{
				pChainedPuzzleState state = chainedPuzzle.m_stateReplicator.State;
				pChainedPuzzleState val = new pChainedPuzzleState
				{
					status = (eChainedPuzzleStatus)0,
					currentSurvivalWave_EventID = state.currentSurvivalWave_EventID,
					isSolved = false,
					isActive = false
				};
				chainedPuzzle.m_stateReplicator.InteractWithState(val, new pChainedPuzzleInteraction
				{
					type = (eChainedPuzzleInteraction)2
				});
			}
			static void ResetChild(iChainedPuzzleCore ICore)
			{
				CP_Bioscan_Core val2 = ((Il2CppObjectBase)ICore).TryCast<CP_Bioscan_Core>();
				if ((Object)(object)val2 != (Object)null)
				{
					CP_Holopath_Spline val3 = ((Il2CppObjectBase)val2.m_spline).Cast<CP_Holopath_Spline>();
					CP_PlayerScanner val4 = ((Il2CppObjectBase)val2.PlayerScanner).Cast<CP_PlayerScanner>();
					val4.ResetScanProgression(0f);
					val2.Deactivate();
				}
				else
				{
					CP_Cluster_Core val5 = ((Il2CppObjectBase)ICore).TryCast<CP_Cluster_Core>();
					if ((Object)(object)val5 == (Object)null)
					{
						EOSLogger.Error("ResetChild: found iChainedPuzzleCore that is neither CP_Bioscan_Core nor CP_Cluster_Core...");
					}
					else
					{
						CP_Holopath_Spline val6 = ((Il2CppObjectBase)val5.m_spline).Cast<CP_Holopath_Spline>();
						foreach (iChainedPuzzleCore item2 in (Il2CppArrayBase<iChainedPuzzleCore>)(object)val5.m_childCores)
						{
							ResetChild(item2);
						}
						val5.Deactivate();
					}
				}
			}
		}
	}
	public static class TSL_Wrapper
	{
		public static LocalizedText ParseToLocalizedText(this LocaleText text)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			return new LocalizedText
			{
				UntranslatedText = text.ParseTextFragments(),
				Id = 0u
			};
		}

		public unsafe static string ParseTextFragments(this LocaleText input)
		{
			return ((object)(*(LocaleText*)(&input))/*cast due to .constrained prefix*/).ToString().ParseTextFragments();
		}

		public static string ParseTextFragments(this string input)
		{
			return (InteropAPI.Call("TSL.ParseTextFragments", new object[1] { input }) as string) ?? input;
		}
	}
	public class EOSColor
	{
		public float r { get; set; }

		public float g { get; set; }

		public float b { get; set; }

		public float a { get; set; } = 1f;

		public Color ToUnityColor()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color(r, g, b, a);
		}
	}
	public static class VanillaTMPPros
	{
		public const string VANILLA_CP_PREFAB_PATH = "Assets/AssetPrefabs/Complex/Generic/ChainedPuzzles/CP_Bioscan_sustained_RequireAll.prefab";

		public static GameObject Instantiate(GameObject parent = null)
		{
			GameObject loadedAsset = AssetAPI.GetLoadedAsset<GameObject>("Assets/AssetPrefabs/Complex/Generic/ChainedPuzzles/CP_Bioscan_sustained_RequireAll.prefab");
			if ((Object)(object)loadedAsset == (Object)null)
			{
				EOSLogger.Error("VanillaTMPPros.Instantiate: Cannot find TMPPro from vanilla CP!");
				return null;
			}
			GameObject gameObject = ((Component)loadedAsset.transform.GetChild(0).GetChild(1).GetChild(0)).gameObject;
			return ((Object)(object)parent != (Object)null) ? Object.Instantiate<GameObject>(gameObject.gameObject, parent.transform) : Object.Instantiate<GameObject>(gameObject.gameObject);
		}
	}
	public class Vec4 : Vec3
	{
		[JsonPropertyOrder(-9)]
		public float w { get; set; } = 0f;

		public Vector4 ToVector4()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(base.x, base.y, base.z, w);
		}
	}
	public class Vec3
	{
		[JsonPropertyOrder(-10)]
		public float x { get; set; }

		[JsonPropertyOrder(-10)]
		public float y { get; set; }

		[JsonPropertyOrder(-10)]
		public float z { get; set; }

		public Vector3 ToVector3()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(x, y, z);
		}

		public Quaternion ToQuaternion()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Euler(x, y, z);
		}
	}
	public static class EOSLogger
	{
		private static ManualLogSource logger = Logger.CreateLogSource("ExtraObjectiveSetup");

		private static string Timestamped(string str)
		{
			return "[" + DateTime.Now.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture) + "] " + str;
		}

		public static void Log(string format, params object[] args)
		{
			Log(string.Format(format, args));
		}

		public static void Log(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)8, (object)Timestamped(str));
			}
		}

		public static void Warning(string format, params object[] args)
		{
			Warning(string.Format(format, args));
		}

		public static void Warning(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)4, (object)Timestamped(str));
			}
		}

		public static void Error(string format, params object[] args)
		{
			Error(string.Format(format, args));
		}

		public static void Error(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)2, (object)Timestamped(str));
			}
		}

		public static void Debug(string format, params object[] args)
		{
			Debug(string.Format(format, args));
		}

		public static void Debug(string str)
		{
			if (logger != null)
			{
				logger.Log((LogLevel)8, (object)Timestamped(str));
			}
		}
	}
	public static class LocalPlayer
	{
		private static int? _InstanceID;

		private static bool _started;

		public static bool HasAgent { get; private set; }

		public static PlayerAgent Agent { get; private set; }

		public static LocalPlayerAgent LocalAgent { get; private set; }

		public static bool TryGetAgent(out PlayerAgent agent)
		{
			agent = Agent;
			return HasAgent;
		}

		public static bool TryGetLocalAgent(out LocalPlayerAgent agent)
		{
			agent = LocalAgent;
			return HasAgent;
		}

		public static Vector3 GetPosition()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HasAgent ? ((Agent)Agent).Position : Vector3.zero;
		}

		public static Vector3 GetPosition(Vector3 fallback)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HasAgent ? ((Agent)Agent).Position : fallback;
		}

		public static Vector3 GetEyePosition()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HasAgent ? ((Agent)Agent).EyePosition : Vector3.zero;
		}

		public static Vector3 GetEyePosition(Vector3 fallback)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HasAgent ? ((Agent)Agent).EyePosition : fallback;
		}

		internal static void Init()
		{
			AssetAPI.OnStartupAssetsLoaded += StartPolling;
			if (AssetAPI.Status != null && AssetAPI.Status.Ready)
			{
				StartPolling();
			}
		}

		private static void StartPolling()
		{
			if (!_started)
			{
				_started = true;
				CoroutineDispatcher.StartCoroutine(UpdatePlayerInfo());
			}
		}

		private static IEnumerator UpdatePlayerInfo()
		{
			while (true)
			{
				if (PlayerManager.HasLocalPlayerAgent())
				{
					PlayerAgent agent = PlayerManager.GetLocalPlayerAgent();
					int instanceID = ((Object)agent).GetInstanceID();
					if (!_InstanceID.HasValue || _InstanceID.Value != instanceID)
					{
						Agent = agent;
						LocalAgent = ((Il2CppObjectBase)agent).Cast<LocalPlayerAgent>();
						_InstanceID = instanceID;
						HasAgent = true;
					}
				}
				else
				{
					Agent = null;
					LocalAgent = null;
					_InstanceID = null;
					HasAgent = false;
				}
				yield return null;
			}
		}
	}
}
namespace ExtraObjectiveSetup.Tweaks.TerminalTweak
{
	public struct TerminalState
	{
		public bool Enabled;

		public bool Approached;

		private int _data;

		private byte _length;

		public bool[] Value
		{
			readonly get
			{
				bool[] array = new bool[_length];
				for (int i = 0; i < _length; i++)
				{
					array[i] = (_data & (1 << i)) != 0;
				}
				return array;
			}
			set
			{
				if (value.Length > 32)
				{
					return;
				}
				_data = 0;
				_length = (byte)value.Length;
				for (int i = 0; i < value.Length; i++)
				{
					if (value[i])
					{
						_data |= 1 << i;
					}
				}
			}
		}

		public TerminalState()
		{
			Enabled = true;
			Approached = false;
			_data = 0;
			_length = 0;
		}

		public TerminalState(bool Enabled)
		{
			_data = 0;
			_length = 0;
			this.Enabled = true;
			Approached = false;
			this.Enabled = Enabled;
		}

		public TerminalState(bool[] logFileRead)
		{
			_data = 0;
			_length = 0;
			Enabled = true;
			Approached = false;
			Value = logFileRead;
		}

		public TerminalState(TerminalState o)
		{
			Enabled = true;
			Approached = false;
			Enabled = o.Enabled;
			Approached = o.Approached;
			_data = o._data;
			_length = o._length;
		}
	}
	public class TerminalWrapper
	{
		private readonly Dictionary<string, List<WardenObjectiveEventData>> logFileEvents = new Dictionary<string, List<WardenObjectiveEventData>>();

		private readonly List<string> logFileNames = new List<string>();

		public LG_ComputerTerminal lgTerminal { get; private set; }

		public StateReplicator<TerminalState> stateReplicator { get; private set; }

		private ExpeditionTerminalsDefinition expeditionTerminalDefinition { get; set; } = null;

		private void ChangeStateUnsynced(bool enabled)
		{
			EOSLogger.Debug($"{lgTerminal.ItemKey} state, enabled: {enabled}");
			lgTerminal.OnProximityExit();
			Interact_ComputerTerminal componentInChildren = ((Component)lgTerminal).GetComponentInChildren<Interact_ComputerTerminal>(true);
			bool flag = enabled;
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Behaviour)componentInChildren).enabled = flag;
				((Interact_Base)componentInChildren).SetActive(flag);
			}
			lgTerminal.m_interfaceScreen.SetActive(flag);
			lgTerminal.m_loginScreen.SetActive(flag);
			if ((Object)(object)lgTerminal.m_text != (Object)null)
			{
				((Behaviour)lgTerminal.m_text).enabled = flag;
			}
			if (!flag)
			{
				PlayerAgent localInteractionSource = lgTerminal.m_localInteractionSource;
				if ((Object)(object)localInteractionSource != (Object)null && localInteractionSource.FPItemHolder.InTerminalTrigger)
				{
					lgTerminal.ExitFPSView();
				}
			}
		}

		public void ChangeState(bool enabled)
		{
			ChangeStateUnsynced(enabled);
			if (SNet.IsMaster)
			{
				StateReplicator<TerminalState> obj = stateReplicator;
				TerminalState state = stateReplicator.State;
				state.Enabled = enabled;
				obj.SetState(state);
			}
		}

		public void ChangeState()
		{
			if (SNet.IsMaster && !stateReplicator.State.Approached)
			{
				StateReplicator<TerminalState> obj = stateReplicator;
				TerminalState state = stateReplicator.State;
				state.Approached = true;
				obj.SetState(state);
			}
		}

		public void ReceiveCommand(TERM_Command cmd, string param)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			if (expeditionTerminalDefinition == null)
			{
				return;
			}
			if (SNet.IsMaster && (int)cmd == 29)
			{
				ChangeState(param);
			}
			if ((int)cmd == 31)
			{
				float delay;
				List<WardenObjectiveEventData> events;
				if (!lgTerminal.EvaluatePassword(param))
				{
					List<WardenObjectiveEventData> eventsOnPasswordInputFailure = expeditionTerminalDefinition.EventsOnPasswordInputFailure;
					float num = 2.6f;
					delay = num;
					events = eventsOnPasswordInputFailure;
				}
				else
				{
					List<WardenObjectiveEventData> eventsOnPasswordInputSuccess = expeditionTerminalDefinition.EventsOnPasswordInputSuccess;
					float num = 2.8f;
					delay = num;
					events = eventsOnPasswordInputSuccess;
				}
				ExecuteEvents(events, delay);
			}
		}

		public void ChangeState(string fileName)
		{
			int num = logFileNames.IndexOf(fileName);
			if (expeditionTerminalDefinition != null && stateReplicator != null && num != -1)
			{
				bool[] value = stateReplicator.State.Value;
				bool[] array = new bool[logFileNames.Count];
				for (int i = 0; i < value.Length && i < array.Length; i++)
				{
					array[i] = value[i];
				}
				if (!array[num])
				{
					array[num] = true;
					StateReplicator<TerminalState> obj = stateReplicator;
					TerminalState state = stateReplicator.State;
					state.Value = array;
					obj.SetState(state);
				}
			}
		}

		private void OnStateChanged(TerminalState oldState, TerminalState newState, bool isRecall)
		{
			if (oldState.Enabled != newState.Enabled)
			{
				ChangeStateUnsynced(newState.Enabled);
			}
			if (expeditionTerminalDefinition == null || isRecall)
			{
				return;
			}
			if (!oldState.Approached && newState.Approached)
			{
				ExecuteEvents(expeditionTerminalDefinition.EventsOnApproach, 0f);
			}
			bool[] value = oldState.Value;
			bool[] value2 = newState.Value;
			for (int i = 0; i < logFileNames.Count; i++)
			{
				bool flag = i < value.Length && value[i];
				bool flag2 = i < value2.Length && value2[i];
				if (!flag && flag2 && logFileEvents.TryGetValue(logFileNames[i], out var value3))
				{
					ExecuteEvents(value3, 3f);
				}
			}
		}

		private void ExecuteEvents(List<WardenObjectiveEventData> events, float delay)
		{
			if (events != null && events.Count != 0)
			{
				if (delay <= 0f)
				{
					WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(ListExtensions.ToIl2Cpp<WardenObjectiveEventData>(events), (eWardenObjectiveEventTrigger)0, true, 0f, (Il2CppStructArray<eWardenObjectiveEventType>)null);
				}
				else
				{
					CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(DelayedEvents(events, delay)), (Action)null);
				}
			}
		}

		private static IEnumerator DelayedEvents(List<WardenObjectiveEventData> events, float delay)
		{
			yield return (object)new WaitForSeconds(delay);
			WardenObjectiveManager.CheckAndExecuteEventsOnTrigger(ListExtensions.ToIl2Cpp<WardenObjectiveEventData>(events), (eWardenObjectiveEventTrigger)0, true, 0f, (Il2CppStructArray<eWardenObjectiveEventType>)null);
		}

		private void SetupExpeditionDefinition()
		{
			if (!ExpeditionDefinitionManager.Current.TryGetTerminalDefinitionFromInstance(lgTerminal, out var termDef))
			{
				return;
			}
			expeditionTerminalDefinition = termDef;
			foreach (TerminalLogFileEvents logFile in termDef.LogFiles)
			{
				if (!string.IsNullOrWhiteSpace(logFile.FileName))
				{
					string text = logFile.FileName.ToUpperInvariant();
					logFileEvents[text] = logFile.EventsOnFileRead;
					logFileNames.Add(text);
				}
			}
		}

		public static TerminalWrapper Instantiate(LG_ComputerTerminal lgTerminal, uint replicatorID)
		{
			if ((Object)(object)lgTerminal == (Object)null || replicatorID == 0)
			{
				return null;
			}
			TerminalWrapper terminalWrapper = new TerminalWrapper();
			terminalWrapper.lgTerminal = lgTerminal;
			terminalWrapper.stateReplicator = StateReplicator<TerminalState>.Create(replicatorID, new TerminalState
			{
				Enabled = true
			}, (LifeTimeType)1, (IStateReplicatorHolder<TerminalState>)null);
			terminalWrapper.stateReplicator.OnStateChanged += terminalWrapper.OnStateChanged;
			terminalWrapper.SetupExpeditionDefinition();
			return terminalWrapper;
		}

		private TerminalWrapper()
		{
		}
	}
	public static class SerialGeneratorManager
	{
		private class ShuffledStepArray
		{
			private readonly string[] _values;

			private readonly int[] _order;

			private int _step = -1;

			public ShuffledStepArray(IEnumerable<string> values)
			{
				_values = values.Distinct().ToArray();
				_order = Enumerable.Range(0, _values.Length).ToArray();
				for (int num = _order.Length - 1; num > 0; num--)
				{
					int num2 = _random.Next(0, num + 1);
					ref int reference = ref _order[num];
					ref int reference2 = ref _order[num2];
					int num3 = _order[num2];
					int num4 = _order[num];
					reference = num3;
					reference2 = num4;
				}
			}

			public string Next()
			{
				_step++;
				if (_step >= _order.Length)
				{
					_step = 0;
				}
				return _values[_order[_step]];
			}
		}

		public enum CodeWordLength
		{
			Three = 3,
			Four,
			Five,
			Six,
			Seven
		}

		public const string AUTOGEN_GUID = "000-the_tavern-AutogenRundown";

		public const string LONGERCODES_GUID = "com.Brandont.LongerCodes";

		private static Random _random;

		private static readonly bool _hasPluginConflict;

		private static readonly Dictionary<CodeWordLength, ShuffledStepArray> _codeWords;

		private static ShuffledStepArray _hardPrefixes;

		public static readonly string[] CodeWordPrefixes;

		public static readonly string[] HardCodeWordPrefixes;

		public static readonly string[] ThreeLetterWords;

		public static readonly string[] FourLetterWords;

		public static readonly string[] FiveLetterWords;

		public static readonly string[] SixLetterWords;

		public static readonly string[] SevenLetterWords;

		static SerialGeneratorManager()
		{
			_random = null;
			_codeWords = new Dictionary<CodeWordLength, ShuffledStepArray>();
			_hardPrefixes = null;
			CodeWordPrefixes = new string[27]
			{
				"X01", "X02", "X03", "X04", "X05", "X06", "X07", "X08", "X09", "Y01",
				"Y02", "Y03", "Y04", "Y05", "Y06", "Y07", "Y08", "Y09", "Z01", "Z02",
				"Z03", "Z04", "Z05", "Z06", "Z07", "Z08", "Z09"
			};
			HardCodeWordPrefixes = new string[84]
			{
				"A01", "A02", "A03", "A04", "A05", "A06", "A07", "A08", "A09", "A10",
				"A11", "A12", "B01", "B02", "B03", "B04", "B05", "B06", "B07", "B08",
				"B09", "B10", "B11", "B12", "C01", "C02", "C03", "C04", "C05", "C06",
				"C07", "C08", "C09", "C10", "C11", "C12", "W01", "W02", "W03", "W04",
				"W05", "W06", "W07", "W08", "W09", "W10", "W11", "W12", "X01", "X02",
				"X03", "X04", "X05", "X06", "X07", "X08", "X09", "X10", "X11", "X12",
				"Y01", "Y02", "Y03", "Y04", "Y05", "Y06", "Y07", "Y08", "Y09", "Y10",
				"Y11", "Y12", "Z01", "Z02", "Z03", "Z04", "Z05", "Z06", "Z07", "Z08",
				"Z09", "Z10", "Z11", "Z12"
			};
			ThreeLetterWords = new string[300]
			{
				"ace", "act", "add", "age", "ago", "aid", "aim", "air", "ale", "all",
				"and", "ant", "any", "ape", "apt", "arc", "are", "arm", "art", "ash",
				"ask", "ate", "bad", "bag", "ban", "bar", "bat", "bay", "bed", "bee",
				"beg", "bet", "bid", "big", "bin", "bit", "bob", "bog", "boo", "bow",
				"box", "boy", "bud", "bug", "bun", "bus", "but", "buy", "cab", "can",
				"cap", "car", "cat", "cob", "cod", "cog", "cop", "cow", "cry", "cub",
				"cup", "cut", "dad", "dap", "day", "den", "dew", "did", "die", "dig",
				"dim", "dip", "dog", "dot", "dry", "due", "duo", "ear", "eat", "egg",
				"ego", "end", "era", "eve", "eye", "fan", "far", "fat", "fed", "fee",
				"few", "fig", "fin", "fir", "fit", "fix", "fly", "fog", "for", "fox",
				"fry", "fun", "fur", "gap", "gas", "get", "gig", "god", "got", "gum",
				"gun", "guy", "gym", "had", "ham", "has", "hat", "hay", "hem", "hen",
				"her", "hey", "hid", "him", "hip", "his", "hit", "hot", "how", "hub",
				"hue", "hug", "hum", "hut", "ice", "ill", "ink", "inn", "ion", "its",
				"jam", "jar", "jaw", "jet", "job", "jog", "joy", "jug", "key", "kid",
				"kin", "kit", "lab", "lad", "lag", "lap", "law", "lay", "led", "leg",
				"let", "lid", "lie", "lip", "lit", "log", "lot", "low", "mad", "man",
				"map", "mat", "may", "men", "met", "mix", "mob", "mom", "mop", "mud",
				"mug", "nap", "net", "new", "nod", "not", "now", "nut", "oak", "oar",
				"odd", "off", "oil", "old", "one", "ore", "our", "out", "owe", "owl",
				"own", "pad", "pal", "pan", "par", "pat", "pay", "pea", "pen", "per",
				"pet", "pie", "pig", "pin", "pit", "pop", "pot", "pub", "put", "rag",
				"ram", "ran", "rap", "rat", "raw", "ray", "red", "rib", "rid", "rig",
				"rim", "rip", "rob", "rod", "rot", "row", "run", "sad", "sag", "sap",
				"sat", "saw", "say", "sea", "see", "set", "sew", "she", "shy", "sin",
				"sip", "sir", "sit", "six", "ski", "sky", "son", "spy", "sue", "sun",
				"tab", "tag", "tan", "tap", "tar", "tax", "tea", "ten", "the", "tie",
				"tin", "tip", "toe", "ton", "too", "top", "toy", "try", "two", "use",
				"van", "vet", "via", "war", "was", "way", "web", "wed", "wet", "who",
				"why", "win", "wit", "won", "wow", "yes", "yet", "you", "zip", "zoo"
			};
			FourLetterWords = new string[733]
			{
				"jazz", "fuzz", "quiz", "jack", "jump", "junk", "cozy", "joke", "jive", "jeep",
				"lazy", "flux", "maze", "jury", "jobs", "mojo", "foxy", "jaws", "zoom", "kick",
				"gaze", "buck", "lynx", "puck", "flex", "pump", "back", "exam", "bump", "zone",
				"pack", "quit", "expo", "cuff", "jolt", "jail", "join", "just", "pick", "comb",
				"size", "biff", "much", "bomb", "hoax", "luck", "camp", "hack", "tzar", "duck",
				"hawk", "funk", "punk", "chip", "chew", "chef", "next", "club", "neck", "iffy",
				"knob", "hymn", "know", "folk", "flak", "dump", "deck", "whip", "milk", "hulk",
				"lack", "walk", "lump", "lock", "monk", "copy", "baby", "pulp", "numb", "hemp",
				"bank", "plum", "pawn", "hype", "beak", "sock", "gulf", "view", "kiwi", "verb",
				"dunk", "husk", "lamb", "bark", "peak", "vice", "vibe", "lamp", "mark", "mask",
				"week", "make", "damp", "weak", "wake", "work", "park", "levy", "skip", "bike",
				"wave", "sick", "envy", "flew", "flaw", "flip", "flop", "flow", "taxi", "flap",
				"film", "five", "plug", "pork", "poke", "fork", "perk", "keep", "king", "bake",
				"tick", "puma", "yank", "exit", "axis", "fake", "limb", "text", "cube", "move",
				"bowl", "book", "wolf", "blow", "navy", "cook", "cake", "clip", "rock", "cave",
				"claw", "clap", "wing", "wife", "brow", "fang", "farm", "riff", "pull", "ugly",
				"epic", "clay", "kind", "kill", "ramp", "face", "fact", "help", "fame", "pope",
				"form", "pony", "busy", "prop", "spam", "half", "busy", "fund", "full", "fury",
				"poem", "swim", "firm", "flag", "pipe", "yawn", "foam", "bull", "play", "nuke",
				"wasp", "warm", "such", "warp", "crab", "give", "hook", "link", "worm", "glow",
				"crop", "crow", "crew", "when", "hive", "push", "golf", "coma", "very", "beam",
				"beef", "inch", "body", "talk", "huge", "holy", "home", "hope", "tank", "rank",
				"rich", "mild", "menu", "mesh", "moth", "mule", "plan", "page", "oval", "oven",
				"path", "knee", "lawn", "lake", "itch", "kilo", "math", "like", "skin", "live",
				"sink", "love", "shop", "show", "silk", "look", "drum", "down", "volt", "void",
				"vine", "wage", "dawn", "dark", "dive", "diva", "wall", "wash", "echo", "type",
				"fill", "fall", "find", "fish", "turk", "foul", "twig", "evil", "etch", "bell",
				"bend", "bath", "bald", "ball", "band", "blur", "bold", "blue", "bill", "army",
				"clan", "clue", "city", "cold", "both", "brag", "burn", "wild", "cash", "cell",
				"will", "wind", "cage", "call", "desk", "grow", "game", "germ", "gasp", "grip",
				"fuel", "them", "frog", "gang", "grab", "must", "hill", "name", "gold", "mute",
				"card", "risk", "wine", "nice", "swan", "they", "news", "mint", "mile", "cone",
				"corn", "scan", "cool", "cure", "cute", "muse", "coin", "hold", "save", "coal",
				"moon", "mono", "code", "mood", "yell", "guru", "take", "task", "able", "acid",
				"pool", "pole", "plot", "yoga", "ally", "hall", "over", "hell", "wool", "wood",
				"bird", "once", "only", "omen", "bolt", "bone", "open", "born", "bead", "pelt",
				"peel", "barn", "pure", "word", "paid", "bent", "belt", "mini", "town", "duty",
				"dull", "lama", "lame", "visa", "lady", "vest", "idly", "spur", "slip", "slim",
				"slow", "slug", "took", "slam", "skit", "slap", "left", "snow", "hunt", "drop",
				"drip", "drug", "snug", "hurl", "soak", "leap", "draw", "vote", "leaf", "snip",
				"kite", "tuba", "fine", "soup", "span", "feed", "feel", "twin", "food", "foil",
				"fool", "flat", "tube", "vase", "kiss", "vast", "fade", "fail", "ever", "spin",
				"life", "snap", "made", "loaf", "deep", "long", "main", "weed", "mail", "want",
				"loop", "lush", "mean", "meal", "doom", "lift", "lily", "lime", "deny", "dime",
				"lips", "taco", "yard", "urge", "trip", "stew", "undo", "spit", "trim", "semi",
				"were", "west", "scar", "tame", "time", "your", "yarn", "wire", "snag", "wise",
				"raft", "rush", "step", "rely", "slay", "ring", "ripe", "roof", "rope", "robe",
				"rift", "rice", "thin", "then", "wait", "trap", "room", "sift", "tidy", "wart",
				"spot", "same", "stab", "soft", "stem", "term", "sing", "sofa", "soap", "race",
				"sign", "song", "safe", "some", "cost", "core", "lend", "coat", "cast", "case",
				"logo", "horn", "hood", "hour", "hurt", "hint", "hole", "dish", "land", "dash",
				"lash", "item", "mate", "boat", "boot", "mass", "miss", "mist", "bite", "mess",
				"boss", "care", "gain", "free", "frat", "fear", "fate", "feet", "fast", "foot",
				"fort", "fits", "fist", "fire", "halo", "hard", "drag", "doll", "hide", "herd",
				"head", "goal", "edge", "girl", "gone", "dual", "grin", "duel", "good", "grid",
				"dune", "oboe", "aged", "omit", "oily", "atom", "noun", "nosy", "pest", "post",
				"pose", "port", "past", "pass", "beer", "most", "beta", "best", "bait", "bias",
				"more", "unit", "goat", "runt", "this", "easy", "dust", "odds", "shoe", "rash",
				"duet", "airy", "that", "tell", "tend", "told", "used", "send", "nail", "tuna",
				"sand", "tune", "sell", "turn", "tall", "rage", "eery", "toll", "gear", "gate",
				"noon", "yeti", "deed", "lane", "lard", "none", "deal", "dead", "sold", "dine",
				"idol", "idle", "shot", "dent", "soul", "dial", "nine", "loan", "load", "rosy",
				"lint", "line", "lean", "lead", "lens", "year", "slur", "hero", "hire", "hiss",
				"here", "neon", "done", "ruin", "rule", "need", "hear", "heat", "lord", "host",
				"rude", "stun", "stay", "auto", "dirt", "diet", "door", "dose", "anti", "dire",
				"earn", "else", "does", "edit", "dare", "dart", "user", "data", "date", "tale",
				"lose", "lore", "loss", "lost", "side", "loot", "salt", "sane", "seen", "seed",
				"seal", "list", "last", "soda", "liar", "slot", "less", "rant", "rent", "redo",
				"raid", "rail", "rain", "ride", "nest", "ruse", "rust", "near", "neat", "nose",
				"note", "road", "tent", "tide", "lair", "tile", "teen", "torn", "true", "tool",
				"toad", "tone", "tilt", "soon", "idea", "sure", "sour", "iron", "suit", "rear",
				"iris", "rest", "tsar", "trio", "sort", "rate", "rare", "tree", "site", "tear",
				"stir", "east", "ease", "area", "rise", "roar", "tier", "ties", "test", "star",
				"tire", "rose", "riot"
			};
			FiveLetterWords = new string[1064]
			{
				"about", "actor", "adapt", "adieu", "adobe", "aeons", "after", "again", "agape", "agate",
				"aging", "aglow", "agree", "ahead", "aimed", "aired", "alarm", "alive", "alley", "allow",
				"aloft", "along", "aloud", "alpha", "altar", "alter", "altos", "amiss", "amity", "among",
				"amour", "ample", "amply", "angle", "angry", "aping", "appal", "apply", "aptly", "arena",
				"array", "arson", "ashen", "aside", "asked", "asset", "atlas", "atone", "attic", "audio",
				"audit", "augur", "avail", "awake", "award", "awoke", "axles", "babel", "baits", "baize",
				"baker", "balmy", "banjo", "basal", "based", "baste", "batch", "bathe", "baths", "beads",
				"beams", "bears", "beast", "beaux", "begun", "being", "belie", "bench", "berry", "bible",
				"bides", "bight", "biped", "birch", "black", "blade", "blast", "blend", "bless", "blink",
				"bliss", "blots", "blown", "blues", "blush", "board", "boars", "boast", "bodes", "boggy",
				"boils", "boles", "books", "boons", "boots", "booze", "borne", "bough", "braid", "brake",
				"brats", "bread", "break", "brief", "brier", "brine", "bring", "brink", "briny", "brood",
				"brown", "budge", "bugle", "build", "built", "bulks", "bulls", "bunks", "burnt", "burrs",
				"burst", "buyer", "cabin", "cable", "caked", "cakes", "calms", "camps", "caper", "casks",
				"casts", "cater", "cause", "cedar", "chafe", "chaff", "chain", "chaos", "charm", "chart",
				"chary", "chasm", "chats", "cheat", "check", "cheek", "cheer", "chess", "chide", "child",
				"chill", "choir", "chops", "chord", "chump", "chums", "chunk", "churl", "chute", "cinch",
				"cites", "clash", "clasp", "class", "claws", "clear", "climb", "clips", "clods", "clogs",
				"close", "clout", "clown", "coast", "cobra", "comes", "comic", "cooed", "cools", "cores",
				"corns", "could", "count", "court", "cover", "covey", "crabs", "craft", "crash", "crass",
				"crate", "craze", "creak", "creek", "creep", "crews", "cribs", "crick", "cries", "crime",
				"croak", "croup", "crows", "crude", "cruel", "crumb", "cubes", "curls", "curly", "curve",
				"cycle", "cynic", "dairy", "dames", "damps", "dance", "dared", "dares", "dates", "daubs",
				"dears", "death", "debit", "debts", "decoy", "decry", "deeds", "deeps", "delay", "dells",
				"delta", "demon", "depot", "deuce", "dimes", "dimly", "diner", "ditch", "ditto", "ditty",
				"dizzy", "docks", "dogma", "doing", "doled", "dolls", "dosed", "doses", "doves", "downs",
				"drink", "drone", "ducks", "dukes", "dummy", "dumps", "dunce", "dupes", "dusty", "dwell",
				"dwelt", "eager", "earls", "early", "earth", "eaten", "eater", "edged", "egged", "eight",
				"elate", "elder", "elude", "email", "empty", "ended", "enemy", "ennui", "epics", "equal",
				"equip", "error", "every", "evils", "evoke", "exalt", "excel", "expel", "extra", "faces",
				"false", "fares", "farms", "fasts", "fault", "fears", "feign", "fells", "ferry", "feted",
				"fever", "fiche", "fiefs", "field", "fifth", "fifty", "fight", "files", "filet", "final",
				"fines", "fires", "first", "fishy", "fives", "fjord", "flaky", "flame", "flank", "flaps",
				"flats", "flaws", "fleck", "flees", "flesh", "flier", "fling", "flirt", "float", "flood",
				"floor", "floss", "flows", "flues", "fluke", "flume", "folio", "folks", "foods", "foray",
				"force", "fords", "forks", "forte", "forts", "forum", "found", "fours", "foxes", "frame",
				"fraud", "freer", "frees", "front", "fruit", "fugue", "fully", "fumed", "fumes", "furze",
				"fuses", "gains", "games", "gangs", "gapes", "gases", "gazes", "geese", "gents", "germs",
				"ghost", "giant", "gilds", "gills", "girth", "given", "gives", "glade", "glass", "glean",
				"glint", "glove", "glows", "gnaws", "goads", "godly", "going", "golly", "gongs", "goody",
				"gored", "gourd", "gowns", "grain", "grant", "graph", "grate", "grave", "graze", "great",
				"greed", "greys", "grime", "gross", "group", "grown", "grows", "guard", "guild", "guile",
				"guilt", "gully", "hails", "hairs", "hands", "hangs", "happy", "harms", "harsh", "haste",
				"haven", "heady", "heard", "heart", "hedge", "heirs", "helix", "helps", "hence", "hides",
				"hills", "hilts", "hinds", "hinge", "hives", "hoist", "holds", "holly", "homes", "horde",
				"hours", "house", "howls", "hulks", "human", "hunch", "hunts", "hurts", "icily", "ideas",
				"idiom", "idled", "idler", "idols", "image", "impel", "imply", "incur", "inept", "infer",
				"inter", "irony", "issue", "jacks", "jaunt", "jeans", "jeers", "jelly", "jests", "jetty",
				"jiffy", "jokes", "junks", "karma", "khaki", "kicks", "knack", "knelt", "knits", "knobs",
				"knots", "known", "label", "ladle", "lager", "lambs", "lamed", "lance", "lanes", "lapel",
				"larch", "large", "largo", "larva", "latch", "later", "lawns", "leafy", "leaky", "leans",
				"leapt", "lease", "least", "leave", "ledge", "level", "liege", "liens", "light", "liked",
				"liken", "limbo", "limbs", "limit", "lines", "lions", "lithe", "lived", "livid", "llama",
				"loads", "loans", "loath", "lobby", "lobes", "local", "looks", "looms", "loops", "loser",
				"lousy", "loved", "lower", "lowly", "lucid", "lucky", "lulls", "lunar", "lurid", "lusty",
				"lymph", "lyric", "mains", "maize", "major", "maker", "makes", "males", "mamma", "mange",
				"mango", "mania", "manor", "manse", "march", "mated", "mates", "maybe", "mayor", "mazes",
				"means", "meats", "medal", "media", "meets", "melon", "memes", "merit", "metal", "might",
				"milch", "miles", "milky", "mimes", "mince", "mined", "mines", "mints", "minus", "mirth",
				"mites", "mixed", "moats", "modem", "modes", "moles", "money", "month", "moody", "moral",
				"mores", "mouse", "mover", "mowed", "mower", "munch", "music", "musky", "musty", "myths",
				"naked", "names", "nasal", "nasty", "natty", "naval", "needs", "nerve", "nests", "never",
				"niche", "night", "nooks", "north", "nosed", "oases", "oaten", "odium", "offer", "often",
				"oiled", "olden", "older", "omits", "onion", "opals", "opens", "opera", "order", "other",
				"ounce", "ovals", "owner", "oxide", "paddy", "paler", "pales", "palsy", "panel", "panic",
				"pansy", "pared", "party", "paste", "patio", "paved", "payed", "payer", "peach", "peaks",
				"pears", "pecks", "pelts", "pence", "penne", "peril", "pesky", "pesos", "pests", "petal",
				"phase", "phone", "piled", "pinch", "pines", "pinto", "pints", "pitch", "pivot", "place",
				"plaid", "plant", "plaza", "plush", "poems", "poets", "point", "pokes", "pools", "popes",
				"poppy", "ports", "pound", "pours", "power", "press", "price", "prick", "pries", "prime",
				"privy", "prize", "props", "prosy", "prove", "prows", "proxy", "psalm", "pudgy", "puffy",
				"pumps", "puree", "purge", "putty", "quart", "quays", "queen", "queue", "quips", "quite",
				"raged", "raise", "rated", "raven", "react", "ready", "reaps", "rebus", "reeds", "reeve",
				"refer", "relic", "remit", "renew", "reply", "rests", "rhyme", "rides", "right", "riled",
				"rills", "rimes", "rinse", "ripen", "risen", "risks", "risky", "roads", "roams", "roast",
				"roles", "rolls", "roomy", "roost", "roots", "rosin", "rouge", "rough", "rouse", "rover",
				"rowdy", "rowed", "ruder", "ruins", "ruler", "runes", "ruses", "sagas", "sails", "salsa",
				"salvo", "scalp", "scarf", "scent", "scion", "scold", "scoop", "scope", "scour", "scowl",
				"seals", "sects", "seeds", "seems", "seers", "seize", "sense", "serfs", "serum", "sever",
				"sewed", "shack", "shaft", "shaky", "shale", "shall", "shams", "shape", "share", "shawl",
				"shear", "sheds", "shift", "ships", "shirk", "shoal", "shone", "short", "shout", "showy",
				"shred", "shrub", "siege", "sieve", "signs", "silky", "silly", "since", "siren", "sites",
				"skate", "skies", "skiff", "skips", "skirt", "skull", "slack", "slang", "slave", "sleds",
				"sleek", "sleet", "slept", "slime", "slink", "slips", "sloop", "slope", "slunk", "slush",
				"small", "smash", "smelt", "smite", "smoke", "snags", "snake", "snaky", "snaps", "snarl",
				"snipe", "snuff", "soars", "sober", "socks", "soggy", "songs", "sonny", "sores", "sough",
				"souls", "south", "sowed", "space", "spans", "spark", "spelt", "spicy", "spike", "spins",
				"spire", "split", "spoor", "sprig", "spurn", "squad", "stage", "stags", "stale", "stamp",
				"stank", "stare", "start", "state", "steal", "steep", "stews", "stiff", "still", "stoic",
				"store", "storm", "story", "stove", "strew", "study", "stump", "sucks", "suite", "suits",
				"sully", "surer", "surly", "sweat", "swell", "swept", "swims", "swing", "sworn", "synod",
				"taboo", "tacks", "taint", "taken", "tamed", "tapes", "tardy", "tarry", "tarts", "tasks",
				"taunt", "taxed", "teems", "teeth", "tempo", "temps", "tenet", "tents", "tepid", "texts",
				"thank", "their", "these", "thick", "thing", "think", "third", "those", "three", "thumb",
				"tibia", "tiers", "tight", "tiles", "times", "tires", "toads", "today", "toils", "tolls",
				"tonic", "tooth", "topaz", "topic", "torso", "torts", "tough", "tours", "towed", "toxic",
				"toyed", "trade", "trail", "trash", "treed", "trice", "trick", "tries", "trill", "tripe",
				"trite", "truly", "trump", "trunk", "trust", "tubes", "tunes", "tunic", "tusks", "tweed",
				"twice", "types", "udder", "uncle", "uncut", "under", "unfit", "unsay", "until", "urban",
				"users", "using", "utter", "vales", "vases", "venom", "verbs", "vials", "video", "views",
				"villa", "viola", "visit", "vista", "vogue", "voice", "volts", "voter", "vouch", "vowel",
				"vying", "wakes", "walks", "wants", "warns", "watch", "water", "waxed", "wears", "weave",
				"weeks", "weigh", "whale", "wheel", "whelp", "where", "which", "while", "whine", "whirl",
				"whist", "white", "whole", "whoop", "whose", "wield", "wilds", "wiles", "wills", "winds",
				"wines", "winks", "wiped", "wipes", "wired", "wires", "woman", "women", "words", "works",
				"world", "worst", "worth", "would", "wound", "wrath", "wreak", "wrong", "years", "yield",
				"yoked", "yolks", "young", "yours"
			};
			SixLetterWords = new string[1394]
			{
				"abated", "abbess", "abbots", "abided", "aboard", "abroad", "abrupt", "abused", "abuser", "acacia",
				"accede", "acidic", "acorns", "across", "action", "addict", "adding", "adduce", "adduct", "adjoin",
				"admire", "admits", "adored", "adorns", "adroit", "adults", "agates", "agency", "agenda", "aghast",
				"agrees", "aisles", "albeit", "albums", "alcove", "allium", "allows", "allure", "almost", "alpaca",
				"alpine", "alumna", "always", "ambers", "amidst", "amoeba", "ampere", "amused", "anemia", "anemic",
				"angles", "animas", "anneal", "anodes", "anomie", "answer", "anthem", "anyone", "apices", "apiece",
				"append", "arcana", "arcane", "ardent", "around", "artful", "aspect", "aspire", "assort", "assure",
				"asylum", "atrial", "attack", "attend", "audits", "avatar", "avenge", "avocet", "avowed", "awakes",
				"axioms", "babies", "backer", "backup", "badges", "bagger", "bailer", "baited", "baking", "bamboo",
				"banged", "banger", "banned", "banyan", "baobab", "barbed", "baring", "barked", "barman", "barrel",
				"basket", "basque", "basses", "basted", "batted", "batten", "battle", "baying", "bayous", "beamer",
				"beaver", "become", "bedlam", "befall", "before", "begone", "behind", "behold", "beings", "belted",
				"belter", "bended", "better", "bevels", "biased", "biceps", "bidden", "bidder", "biller", "binder",
				"biomes", "bionic", "birder", "bisect", "blades", "blamed", "blames", "blasts", "blazer", "blazon",
				"blenny", "blight", "blocky", "blonde", "blooms", "bluest", "boasts", "boater", "bobbed", "bobcat",
				"bogeys", "bolded", "bombed", "boosts", "bosons", "botany", "bougie", "bouton", "bovine", "bowled",
				"bowman", "boxers", "bracer", "breeze", "bright", "brinks", "broads", "broker", "broods", "broths",
				"bruise", "brushy", "bryony", "bucked", "budget", "buffed", "buffer", "buffet", "bugged", "burden",
				"burley", "busker", "busses", "butter", "buyout", "bypass", "cabins", "cached", "called", "caller",
				"calmer", "cancan", "candor", "caning", "canner", "canons", "capita", "carafe", "career", "carman",
				"carols", "cartel", "caucus", "causer", "causes", "caveat", "celebs", "cental", "center", "chaise",
				"chance", "change", "charms", "chased", "chasms", "cheats", "chided", "chiles", "chintz", "chisel",
				"chocks", "choirs", "choker", "chokes", "cholla", "choose", "chords", "chucks", "clefts", "clerks",
				"climes", "cloned", "closed", "cloths", "cloudy", "clowns", "coddle", "coffee", "coffer", "cohort",
				"coined", "coking", "coldly", "comber", "coming", "common", "confit", "conics", "coning", "conned",
				"cookie", "cooper", "coping", "copped", "copter", "corals", "corded", "corked", "corker", "corner",
				"corral", "corset", "cortex", "cougar", "county", "couple", "coupon", "course", "covert", "cozens",
				"cramps", "crated", "craves", "crayon", "creaky", "critic", "crowns", "cruise", "crusts", "crypto",
				"cuboid", "cuddly", "cupids", "curing", "curlew", "curved", "custom", "cutest", "cyclic", "cypher",
				"dabble", "daemon", "daikon", "dampen", "danced", "dances", "danger", "darker", "darned", "darted",
				"dearer", "debate", "debits", "debugs", "decoys", "decree", "deepen", "defeat", "deists", "deltas",
				"dement", "demons", "demote", "demure", "depict", "depose", "depths", "derive", "desire", "detach",
				"detail", "detect", "detest", "devise", "devoid", "diadem", "dialup", "dictum", "digest", "dilate",
				"dimers", "dimmed", "dimmer", "dimple", "dinner", "discos", "discus", "dodges", "dogmas", "dollar",
				"donate", "donkey", "donned", "dosage", "dosing", "doting", "double", "dozers", "draper", "drapes",
				"dreamy", "dredge", "driers", "driver", "dually", "ducats", "duffel", "dumber", "dumped", "dunked",
				"dunker", "during", "duster", "dyadic", "earing", "earths", "earwax", "earwig", "easter", "echoes",
				"eddies", "editor", "eerily", "effete", "effort", "eights", "eighty", "either", "elects", "elicit",
				"eluted", "embark", "embeds", "emcees", "empire", "encore", "energy", "engulf", "enjoys", "enlace",
				"enough", "enrage", "entail", "enters", "entree", "envoys", "equine", "errata", "erupts", "eschew",
				"escrow", "esprit", "essays", "esteem", "esters", "evades", "evenly", "excels", "exhale", "exiles",
				"exodus", "exotic", "expire", "expiry", "extant", "extend", "eyelid", "family", "faster", "father",
				"fathom", "faults", "faulty", "favors", "feeble", "feeler", "feline", "felted", "femmes", "fenced",
				"fences", "fender", "fescue", "fiddle", "fiends", "filing", "filmed", "firmer", "fixate", "fixing",
				"fixity", "fizzle", "flaked", "flamed", "flaxen", "flayed", "fleece", "fleets", "flexor", "flicks",
				"flight", "flimsy", "flinch", "flings", "flocks", "floret", "fluffy", "fogged", "foiled", "fondly",
				"fondue", "forced", "forego", "formal", "format", "former", "francs", "freely", "freeze", "friend",
				"fronts", "frosts", "frosty", "frowns", "fruits", "funder", "fungal", "furrow", "futile", "future",
				"gables", "gadfly", "gagged", "gaging", "galore", "gambol", "gamete", "gaming", "gammon", "gander",
				"garage", "garden", "garnet", "gassed", "gather", "gauges", "ghetto", "gibbet", "ginkgo", "givers",
				"giving", "glared", "global", "globes", "gnomes", "goaded", "gobble", "gobies", "goober", "gouges",
				"gourds", "grainy", "grants", "graphs", "grates", "graven", "grebes", "greets", "greyed", "grieve",
				"groats", "groovy", "grovel", "groves", "guilds", "gummed", "gunman", "gunmen", "haggis", "halite",
				"halted", "hamper", "hanger", "hangup", "happen", "harass", "harbor", "having", "headed", "health",
				"hearts", "heated", "heaves", "heddle", "heeded", "height", "helped", "herder", "hereof", "heresy",
				"hermit", "herons", "hiatus", "highly", "hinted", "hipped", "hippie", "hitter", "holler", "hombre",
				"homers", "hominy", "honest", "honeys", "hoodie", "hoopoe", "hooves", "hopper", "horned", "horror",
				"hosing", "hotels", "howled", "hubbub", "hubris", "huddle", "humbly", "humbug", "hummus", "hunker",
				"hurdle", "hushed", "husker", "hymnal", "hyphen", "iceman", "imager", "imbued", "impair", "impugn",
				"inched", "indigo", "indole", "induct", "infant", "infest", "inform", "inking", "inning", "inputs",
				"insane", "inside", "insole", "invite", "inward", "islets", "isobar", "issues", "italic", "jabbed",
				"jacked", "jaunts", "jaunty", "jigger", "jigsaw", "jingle", "jokers", "jovian", "juggle", "juntas",
				"jurors", "kaftan", "karats", "keeper", "ketone", "kicked", "killed", "kimchi", "kindle", "kindly",
				"kiosks", "kismet", "kitbag", "kitted", "kitten", "kittle", "knifed", "knocks", "knowns", "koalas",
				"kvetch", "labile", "lackey", "ladder", "lament", "landau", "landed", "lapdog", "lapels", "laptop",
				"lasing", "lasses", "lasted", "lawyer", "layman", "laymen", "lazily", "league", "leaner", "leaves",
				"legume", "lender", "lesion", "lessee", "liable", "licked", "lifter", "likely", "liming", "limped",
				"limpid", "linage", "linens", "liners", "lingua", "linker", "little", "livery", "living", "loaded",
				"loader", "loaned", "loathe", "locate", "lodges", "looney", "looped", "looser", "looses", "louver",
				"loving", "lowest", "lowing", "lulled", "lumped", "luring", "lurked", "lusted", "luxury", "lyceum",
				"machos", "macros", "maimed", "making", "mallee", "mallow", "malted", "mangle", "maniac", "mantel",
				"manure", "mapper", "marked", "market", "maroon", "masons", "massif", "matter", "maxims", "mayors",
				"medals", "medley", "meeker", "melody", "member", "memory", "menace", "mended", "merely", "merest",
				"merino", "metals", "method", "methyl", "micron", "midair", "midden", "midrib", "mimics", "minced",
				"minors", "minted", "mirage", "misery", "mishap", "missal", "moaned", "mobbed", "mocked", "modern",
				"modest", "modulo", "moiety", "moment", "moneys", "months", "morrow", "mortar", "motels", "mother",
				"mounds", "mounts", "mouthy", "mouton", "museum", "musher", "mussel", "mutant", "mutton", "myopic",
				"myself", "mystic", "mythos", "nagged", "nailed", "nannie", "napped", "napper", "native", "navels",
				"nearby", "neared", "netted", "niacin", "nickel", "nipper", "nipple", "nobler", "noises", "nomads",
				"norths", "notify", "novena", "nudges", "number", "nutmeg", "nutria", "oblate", "obsess", "obtain",
				"obtuse", "occult", "oddest", "oddity", "odious", "offend", "office", "oldest", "online", "opened",
				"openly", "optics", "orbits", "ordain", "orders", "orgies", "origin", "ornate", "osprey", "others",
				"otters", "outdid", "outers", "output", "outrun", "owners", "oxides", "oxygen", "pagans", "paging",
				"pained", "paints", "palate", "paltry", "pandan", "pander", "parens", "parent", "parish", "parkas",
				"parlay", "parley", "parlor", "parody", "parole", "parrot", "parsed", "parses", "partly", "pastas",
				"pastel", "pastor", "payees", "payors", "peaker", "peapod", "pearly", "pecked", "peeler", "peeves",
				"pelvis", "people", "period", "person", "petals", "petite", "petrel", "petted", "phased", "phones",
				"phonic", "photos", "picker", "piddle", "pillar", "pillow", "pinger", "pipped", "pistil", "pistol",
				"plague", "plaids", "plaint", "plated", "plates", "playas", "played", "player", "pleads", "please",
				"plexus", "plural", "points", "police", "policy", "polkas", "polled", "poplar", "poppet", "portal",
				"posses", "possum", "postal", "poured", "precis", "prefer", "preset", "pretty", "preyed", "prised",
				"prissy", "proofs", "propel", "propyl", "proven", "prover", "pseudo", "public", "puffin", "pulley",
				"pulser", "pumper", "pundit", "pupils", "puppet", "purged", "purple", "puzzle", "pylons", "quarry",
				"queues", "quiver", "rabbit", "rabble", "rabies", "racing", "racked", "racoon", "radian", "radios",
				"raffia", "raffle", "raider", "rained", "ramjet", "rammed", "ranged", "ranked", "ranker", "rapper",
				"rashly", "rather", "ravers", "ravine", "really", "reaper", "reason", "rebels", "rebind", "recast",
				"recede", "reckon", "record", "recoup", "rectal", "rector", "redden", "redial", "redraw", "reefer",
				"refers", "refuel", "refute", "regime", "region", "reheat", "reined", "relate", "relent", "relied",
				"remain", "remand", "remits", "remove", "renege", "renown", "rented", "repeat", "report", "rescan",
				"reseal", "resent", "resign", "result", "retake", "retest", "return", "reverb", "revere", "review",
				"revise", "revive", "revolt", "revues", "revved", "rewire", "rhesus", "rhumba", "rhymer", "rhymes",
				"ribbon", "riches", "riding", "riffle", "rigged", "rigger", "righty", "rioted", "ripper", "riprap",
				"rising", "roader", "roared", "robbed", "rookie", "rooter", "rosary", "rotors", "rotten", "roughs",
				"roused", "rouser", "routes", "royals", "rubber", "rudder", "rueful", "rufous", "ruling", "rushed",
				"sachem", "saddle", "safari", "sagged", "sailer", "sanely", "sanity", "sarong", "satiny", "satyrs",
				"savant", "saying", "scalps", "scarfs", "schist", "school", "scopes", "scorch", "scored", "scorer",
				"scores", "scorns", "scours", "scouse", "scouts", "scrape", "scraps", "scrawl", "scrips", "scroll",
				"scrubs", "sculls", "season", "seaway", "secede", "second", "secret", "sector", "sedges", "seeker",
				"sender", "septic", "series", "setups", "sevens", "sewage", "shader", "shades", "shafts", "shaggy",
				"shales", "shamed", "shanty", "shaper", "shapes", "sharps", "sherry", "shiner", "shines", "shoppe",
				"shorty", "should", "shrews", "shrink", "shroud", "shrubs", "shunts", "sicker", "sidled", "sieves",
				"silage", "simmer", "simply", "sinewy", "single", "singly", "siphon", "sipper", "sitcom", "sitter",
				"skater", "sketch", "skills", "skyway", "slalom", "slings", "sloppy", "slough", "smacks", "smarmy",
				"smidge", "smiley", "smocks", "smudge", "smugly", "snacks", "snippy", "snuffy", "soaked", "social",
				"socked", "soiled", "soothe", "sorrow", "sought", "souped", "sowing", "spaced", "sparse", "specie",
				"specks", "speeds", "spells", "spices", "spiffy", "spinal", "spined", "spoons", "spores", "sprang",
				"sprays", "spring", "sprite", "sprung", "spurns", "spying", "square", "squawk", "staple", "stared",
				"stares", "starts", "stater", "states", "statue", "steamy", "steels", "steers", "stifle", "stinky",
				"stints", "stitch", "stoked", "stomps", "stools", "storks", "stowed", "straws", "street", "strewn",
				"strode", "strong", "strove", "struck", "stunts", "stupid", "subpar", "subsea", "subset", "subtly",
				"sucker", "suckle", "sudden", "sugars", "suited", "sunder", "sundew", "sundog", "sundry", "suplex",
				"surety", "surfer", "surged", "swales", "swamps", "swathe", "swears", "sweaty", "swifty", "swirls",
				"swivel", "swords", "syndic", "syrupy", "system", "tablet", "tacker", "taking", "talked", "tamper",
				"tangle", "tanked", "tanner", "tapped", "tapper", "target", "tattle", "tawdry", "teases", "teensy",
				"temper", "tempts", "tended", "tenner", "tennis", "tented", "termed", "thanks", "things", "though",
				"throat", "throbs", "throne", "thrush", "tickle", "tildes", "tilted", "tilter", "timers", "tiptoe",
				"tiptop", "tissue", "titers", "toasty", "toffee", "toiled", "tokens", "tomato", "tomcat", "toners",
				"tonics", "towels", "tracks", "trader", "trains", "treads", "trials", "tricks", "tricky", "troupe",
				"trying", "tsetse", "tufted", "tumult", "tundra", "turbid", "turbos", "turnip", "tuxedo", "twelve",
				"twined", "typify", "ulcers", "umlaut", "uncool", "undone", "undyed", "unhook", "united", "unites",
				"unless", "unlink", "unlock", "unread", "unroll", "unseat", "unspun", "unsung", "untrue", "unused",
				"unveil", "update", "upkeep", "urbane", "urgent", "urging", "ursine", "usable", "utopia", "valets",
				"valued", "valves", "vandal", "varies", "veered", "veiled", "venial", "verily", "vernal", "versed",
				"versus", "vertex", "vestry", "villas", "vining", "violet", "violin", "vireos", "virile", "vistas",
				"vizier", "voodoo", "vortex", "voters", "vowing", "wading", "wagers", "waited", "wanted", "warder",
				"warmly", "weapon", "wetted", "whaler", "whammy", "whence", "whinge", "whiten", "whoops", "wicked",
				"wiener", "wigeon", "wiggle", "wiggly", "wigwam", "window", "winnow", "wintry", "wipers", "within",
				"wolves", "wombat", "woolen", "woolly", "worded", "wormed", "wretch", "wrongs", "yahoos", "yawned",
				"yeoman", "yippee", "yogurt", "zealot", "zenith", "zephyr", "zeroes", "zigzag", "zinger", "zinnia",
				"zodiac", "zombie", "zoomed", "zygote"
			};
			SevenLetterWords = new string[1601]
			{
				"abating", "abiding", "ability", "abolish", "abyssal", "acacias", "academy", "accents", "account", "acquire",
				"acreage", "actions", "acutely", "address", "adjunct", "adjusts", "adviser", "affixed", "affront", "against",
				"aground", "aircrew", "airflow", "airmail", "allelic", "allowed", "allured", "almanac", "almonds", "alpacas",
				"already", "amateur", "amazing", "ambling", "amended", "ammonia", "amorous", "amyloid", "anarchy", "anguish",
				"annexes", "annulus", "another", "answers", "antacid", "antenna", "anthems", "antonym", "anymore", "apostle",
				"apparel", "applies", "aqueous", "archery", "archive", "armband", "armorer", "arouses", "arrival", "arsenic",
				"article", "artless", "arugula", "asylums", "attract", "aunties", "auroras", "austere", "authors", "avenger",
				"avenues", "average", "awakens", "awaking", "awesome", "babbled", "babysit", "backing", "backlog", "badgers",
				"baggage", "ballads", "ballots", "baneful", "banging", "bangles", "banking", "banquet", "baptize", "barking",
				"baronet", "baroque", "barring", "bashful", "basques", "bathtub", "battles", "baubles", "beading", "bearish",
				"beavers", "because", "bedrock", "beepers", "beeping", "befalls", "belcher", "beliefs", "believe", "belongs",
				"belting", "bending", "benefit", "berated", "betrays", "betting", "bettors", "between", "bicycle", "bifocal",
				"biggest", "biology", "biotics", "birding", "bishops", "bitumen", "blacked", "blacken", "blaming", "blankly",
				"bleeder", "blessed", "blinded", "blister", "blitzed", "blocker", "bloomed", "blooper", "blouses", "blowers",
				"blunted", "blurred", "blurted", "blusher", "boarded", "boatmen", "boffins", "boggles", "bolding", "bollard",
				"bombard", "bonuses", "bookend", "bookies", "booklet", "boolean", "boomers", "booster", "boredom", "borings",
				"borough", "bossier", "bothers", "bottles", "bouncer", "bounces", "bowhead", "boycott", "bracing", "brasher",
				"braving", "breaded", "breathy", "breezes", "bribery", "bridals", "briefed", "brights", "brining", "briskly",
				"bristle", "bristly", "broadly", "bromide", "bronzes", "brother", "brought", "brownie", "browsed", "bruises",
				"brutish", "buddies", "budgets", "buffers", "buffets", "bugbear", "bulbous", "bulging", "bulking", "bulldog",
				"bullies", "bullish", "bullpen", "bumpers", "bunched", "bungled", "bunting", "buoyant", "bureaus", "burgers",
				"burrito", "butters", "buttery", "buyouts", "cabanas", "cabinet", "caching", "cadmium", "calcium", "calling",
				"cantons", "capping", "caprice", "captain", "captors", "carafes", "caramel", "caravan", "carcass", "cargoes",
				"carpets", "carrion", "carrots", "cartoon", "castors", "catarrh", "catcher", "catches", "catered", "causing",
				"caveman", "ceasing", "cements", "censors", "censure", "centers", "central", "century", "certain", "ceviche",
				"chafing", "chalice", "challah", "changed", "changes", "channel", "chanted", "chaotic", "chapped", "charger",
				"charted", "chasers", "chasing", "checker", "cherubs", "chevron", "chicory", "chiming", "choline", "chopped",
				"chorale", "chorizo", "chucked", "clapped", "clashed", "classic", "cleanse", "clearly", "clicked", "climbed",
				"clinger", "clipped", "clipper", "clogged", "closely", "closeup", "clotted", "clovers", "clubbed", "coaches",
				"coasted", "coerced", "cognate", "collars", "college", "combust", "comedic", "comment", "commies", "commune",
				"company", "compare", "compels", "compere", "comport", "compose", "conceal", "concert", "concise", "condemn",
				"condors", "conjure", "console", "consume", "contact", "contend", "content", "contest", "control", "convert",
				"cookout", "coolest", "coopers", "cooties", "coppers", "copycat", "cornets", "coronet", "corsage", "cougars",
				"coulomb", "council", "country", "courage", "courant", "coursed", "courses", "covered", "cowbird", "coyotes",
				"cracked", "crackle", "crashed", "creaked", "created", "credits", "crimper", "crimson", "cronies", "cropper",
				"crowing", "crucify", "crudely", "cruelly", "crusher", "crushes", "cubbies", "cubicle", "culture", "culvert",
				"cumulus", "cunning", "currant", "current", "curried", "cushion", "cuticle", "cutlery", "cyclops", "cypress",
				"dabbled", "damping", "damsels", "dancing", "dawning", "daytime", "debater", "debtors", "decease", "decided",
				"decimal", "deckers", "decoder", "decodes", "decreed", "deduced", "deeming", "defiant", "defraud", "defunct",
				"defused", "deicing", "deliver", "deltoid", "demands", "demonic", "demoted", "deniers", "densest", "depicts",
				"deposed", "depress", "dequeue", "derails", "derived", "derives", "designs", "desired", "desktop", "despite",
				"details", "detects", "detente", "devises", "devours", "diabolo", "dialing", "dictate", "diesels", "digests",
				"diggers", "digging", "digital", "dilated", "dilator", "dinette", "diorama", "dirtier", "disable", "disease",
				"dislike", "display", "dispute", "diurnal", "divider", "divides", "divisor", "doctors", "dollars", "dominos",
				"donning", "dossier", "drafted", "dragoon", "dreaded", "drifter", "drinker", "drizzly", "droning", "dubious",
				"durable", "dusting", "dyeable", "eagerly", "earlier", "earlobe", "earners", "earshot", "echelon", "echoing",
				"edibles", "edifice", "edition", "ejected", "elected", "elector", "elution", "embassy", "embolic", "eminent",
				"emirate", "empower", "emptied", "emulate", "encased", "encores", "endgame", "endings", "endowed", "endures",
				"enjoins", "enjoyed", "enlaces", "enraged", "enteric", "envious", "enzymes", "episode", "erosive", "erratum",
				"estates", "evacuee", "evaders", "evasion", "evoking", "evolved", "exactly", "examine", "example", "excises",
				"exciter", "excites", "exempts", "existed", "explain", "exploit", "exports", "expunge", "faculty", "faintly",
				"fairies", "falcons", "fangled", "farmers", "farming", "farther", "fascias", "fastest", "fatally", "fateful",
				"fathers", "favored", "fawning", "federal", "feeders", "feelers", "feeling", "females", "fetched", "fielder",
				"fifteen", "figures", "filling", "finally", "finance", "fishery", "fission", "flaming", "flatbed", "flecked",
				"flicked", "floated", "floored", "flopped", "flowery", "fluidic", "flutter", "foaming", "folders", "fondled",
				"fooling", "footway", "forages", "forceps", "foresaw", "forests", "forgave", "forging", "forgive", "forsake",
				"forward", "framers", "fraying", "freeing", "freezer", "frescos", "freshly", "friends", "frigate", "fringes",
				"fuchsia", "fuelled", "fulcrum", "fumbles", "funnies", "further", "futures", "gallery", "galling", "gallops",
				"gambler", "gangway", "gapping", "garners", "garters", "gasping", "gazelle", "gazette", "gelatin", "general",
				"genetic", "genital", "gestalt", "getting", "gigabit", "giraffe", "glacial", "glamour", "glanced", "glassed",
				"glazing", "gleeful", "glimmer", "glossed", "glutton", "goalies", "gobbler", "godhead", "goofing", "goulash",
				"gracing", "grained", "granary", "grander", "granola", "granted", "grantee", "granule", "grassed", "gravest",
				"graying", "greases", "greater", "greener", "gremlin", "grenade", "griddle", "gripper", "grizzle", "grooved",
				"grosses", "grouchy", "grouped", "growing", "growths", "grudges", "grumble", "guessed", "gumtree", "gymnast",
				"habitat", "hacksaw", "halcyon", "hallows", "hallway", "halting", "hammers", "hamster", "handing", "handoff",
				"hapless", "haploid", "happens", "harmony", "harping", "harpoon", "hastens", "hatches", "haulage", "hawkish",
				"hayseed", "hazards", "healers", "heaping", "heaters", "heavier", "heights", "helmets", "hickory", "himself",
				"hipster", "history", "hitched", "hobnail", "hoedown", "hoisted", "hollers", "hollows", "hooting", "hopeful",
				"hoppers", "hopping", "hormone", "horrors", "hospice", "hostels", "hostile", "hosting", "hotdogs", "hotline",
				"however", "hulking", "humanly", "humbled", "humerus", "humidor", "humming", "hunters", "husband", "huskers",
				"huskies", "idyllic", "ignited", "imagine", "impaler", "imperil", "impiety", "impious", "implies", "imposed",
				"impound", "imprint", "improve", "imputed", "include", "indents", "indexed", "indexer", "indexes", "indicts",
				"indulge", "infects", "inflict", "infuser", "ingress", "injects", "injured", "innings", "inquest", "inroads",
				"insider", "insides", "insight", "insists", "inspect", "instate", "instead", "insured", "insures", "invents",
				"inverse", "ionized", "ionizer", "islands", "isomers", "isotope", "issuers", "jackals", "janitor", "january",
				"jarring", "jazzman", "jeepers", "jellies", "jerking", "jigsaws", "jobbers", "jobsite", "joiners", "joining",
				"jolting", "journal", "judging", "jungles", "justice", "karaoke", "kernels", "ketchup", "ketones", "ketosis",
				"keylock", "keypads", "kicking", "kimonos", "kindred", "kinetic", "kissing", "kitting", "kneeled", "knowhow",
				"labored", "lacking", "lagging", "lagoons", "lancets", "largely", "latches", "lateral", "launder", "lawless",
				"layaway", "leaders", "leading", "leaflet", "leaking", "leaving", "lecture", "leeward", "legumes", "leisure",
				"lemming", "leopard", "lessees", "liberty", "library", "licking", "lifting", "likable", "lilting", "limited",
				"limiter", "lintels", "listens", "listing", "lithium", "liturgy", "livable", "lobbies", "located", "locater",
				"locates", "lockets", "locknut", "lodging", "logbook", "looking", "lookout", "lookups", "looming", "lotions",
				"louvers", "loyalty", "lurkers", "machine", "magical", "magnify", "mahjong", "mailbox", "maiming", "majored",
				"malting", "manager", "manatee", "mangers", "mangoes", "mankind", "mansion", "mariner", "markets", "married",
				"marries", "marshal", "martial", "martyrs", "massing", "mastiff", "mastoid", "matinee", "maudlin", "mauling",
				"maxilla", "meaning", "medical", "mediums", "meeting", "melanin", "members", "mermaid", "message", "meteors",
				"microbe", "middles", "midline", "midterm", "million", "mimosas", "mincing", "minding", "mingled", "mingles",
				"minimum", "minnows", "minuses", "minutes", "miserly", "mislead", "missile", "missing", "mistake", "modeled",
				"modular", "moments", "monarch", "montage", "monthly", "moorhen", "moorish", "morning", "mosaics", "mothers",
				"mountie", "mulling", "mullion", "mumbles", "mummies", "musings", "muskets", "muskrat", "mutable", "mutants",
				"mutates", "mutters", "mystics", "nagging", "napkins", "natural", "nebulae", "nesting", "netball", "netting",
				"network", "nibbles", "nightly", "nipping", "noisily", "noncash", "nonstop", "notable", "notably", "notched",
				"notches", "nothing", "noticed", "novelty", "nozzles", "numbers", "numeric", "nurture", "nutcase", "oakmoss",
				"obviate", "ocarina", "octaves", "october", "offends", "offeror", "officer", "offside", "ominous", "omnibus",
				"onboard", "oneself", "onshore", "openers", "opening", "opinion", "opossum", "optical", "options", "oracles",
				"oranges", "orbital", "ordeals", "outcome", "outfits", "outlets", "outlier", "outrage", "outside", "overdue",
				"overrun", "oversaw", "oxfords", "oysters", "pageant", "paisley", "pampers", "panacea", "pancake", "paneled",
				"panning", "pansies", "papayas", "parable", "paraded", "parapet", "parents", "parfait", "parlors", "paroled",
				"parsley", "parsons", "parties", "passage", "passing", "passive", "pastors", "patella", "patrons", "pattern",
				"pausing", "payable", "payment", "payroll", "pecking", "penalty", "pending", "peonies", "percent", "percept",
				"perches", "perfect", "perfume", "perhaps", "pickets", "picture", "piercer", "pigtail", "pincher", "pinkish",
				"pinless", "pirated", "pitched", "pitfall", "pivoted", "plainer", "plainly", "planets", "planted", "planter",
				"plateau", "platoon", "players", "playing", "pleases", "pliable", "plotter", "plunges", "plywood", "poetess",
				"pointed", "pointer", "pontiff", "pontoon", "pooling", "poppies", "popular", "porcine", "possums", "postbag",
				"postfix", "posting", "postman", "postwar", "potions", "powdery", "powered", "preachy", "preamps", "precise",
				"pregame", "preheat", "premise", "prepare", "present", "preteen", "preying", "primacy", "priming", "prisons",
				"privacy", "private", "problem", "process", "proctor", "prodded", "produce", "product", "profess", "profile",
				"profits", "program", "project", "prolong", "protect", "provide", "proving", "proxied", "proxies", "prudent",
				"psyched", "publish", "puffing", "pulsars", "punched", "punches", "pungent", "puritan", "pursuer", "pushing",
				"pushrod", "putters", "puzzled", "pygmies", "pyramid", "quality", "quantal", "quarrel", "quickly", "quintet",
				"quizzes", "radiate", "raiders", "raiding", "railway", "raining", "rallied", "rambled", "rancher", "ranchos",
				"rangers", "rapidly", "rappers", "rascals", "rattled", "ravioli", "rawhide", "reached", "reacher", "reading",
				"readout", "reasons", "rebuked", "recalls", "recipes", "reckons", "recline", "records", "rectors", "rectory",
				"recurse", "recusal", "recused", "redbird", "reddish", "redfish", "reeling", "reentry", "referee", "reflect",
				"refocus", "reforms", "refuted", "regaled", "regency", "regimen", "regress", "regrets", "regroup", "regular",
				"reissue", "rejoice", "relapse", "related", "relaxed", "release", "reliant", "remakes", "remarks", "remarry",
				"remixed", "remnant", "remodel", "removes", "renames", "rentals", "renters", "reorder", "repeals", "repents",
				"replays", "replete", "reports", "reproof", "repulse", "request", "rescale", "resists", "resound", "respect",
				"restate", "results", "retails", "reticle", "retract", "retread", "returns", "reunion", "reveals", "reveled",
				"revered", "reverse", "reviews", "reviser", "revisor", "revived", "rewinds", "rewrote", "ribbons", "ricotta",
				"ridding", "riddled", "rioting", "ripcord", "ripoffs", "riposte", "rippers", "riveted", "riveter", "roaring",
				"roasted", "roebuck", "rollout", "romaine", "rompers", "roofing", "rooster", "rotator", "rounded", "rounder",
				"rousing", "royalty", "ruffles", "rumbled", "rumored", "rundown", "running", "runtime", "rustled", "saguaro",
				"saintly", "salmons", "salting", "salvage", "sampled", "sandman", "saucers", "savages", "savings", "savored",
				"sayings", "scalper", "scamper", "scanner", "scarcer", "scarier", "scarred", "scatter", "schools", "science",
				"scissor", "scooped", "scooter", "scourge", "scouted", "scraped", "scrapes", "scratch", "scribes", "scrubby",
				"seasons", "seaters", "seconds", "secrete", "section", "seeders", "seethed", "seismic", "selfish", "sellout",
				"serious", "servant", "service", "settles", "several", "shadowy", "shakeup", "shapely", "sharing", "sheared",
				"sheaths", "sheeted", "shellac", "shifted", "shifter", "shingle", "shipper", "shocker", "shoeing", "shovels",
				"showers", "shrieks", "shrinks", "shudder", "shuffle", "sickens", "sidecar", "sigmoid", "signers", "silents",
				"similar", "similes", "sirloin", "sizzler", "skewing", "skidded", "skillet", "skimmed", "skipper", "skylark",
				"slander", "slapped", "sleeper", "slicker", "slivers", "sloping", "smacked", "smarter", "smiling", "smitten",
				"smudges", "smuggle", "sneaked", "sneezed", "snicker", "snorkel", "snuffed", "soaking", "soberly", "society",
				"softest", "softies", "someone", "sonnets", "soothed", "sorcery", "sorrows", "sorters", "sorting", "sources",
				"spatial", "spawner", "spaying", "special", "species", "specify", "specter", "spiders", "spiller", "spindle",
				"spinner", "splints", "spotter", "squalls", "squeals", "squishy", "stabler", "stainer", "stamped", "stapled",
				"starker", "started", "station", "statute", "stereos", "sterner", "stipend", "stopgap", "stopped", "stopper",
				"stories", "storing", "streets", "strolls", "stubble", "student", "studies", "stuffed", "stunned", "subdued",
				"subject", "sublime", "subsume", "subtype", "success", "suggest", "summery", "summons", "sunrise", "sunsets",
				"sunspot", "suppers", "support", "surface", "surfers", "surgeon", "surgery", "surreal", "swapper", "swarmed",
				"swarthy", "sweeper", "swifter", "swisher", "systems", "tablets", "tacitly", "tacking", "tactics", "tailors",
				"talking", "tamping", "tangent", "tangles", "tanners", "tannery", "tannins", "tantrum", "tapioca", "tassels",
				"tatting", "tattoos", "teaches", "teacups", "teasers", "tedious", "tempted", "tempter", "tenable", "tenders",
				"tending", "tenures", "termini", "testbed", "testers", "tetanus", "textual", "theater", "thereon", "thicken",
				"thimble", "thirdly", "thirsty", "thither", "thought", "threads", "through", "thumbed", "thumper", "tickets",
				"tickled", "tidings", "tidying", "tilings", "tinting", "tippers", "tissues", "tithing", "toaster", "toggled",
				"toggles", "toiling", "tonight", "tooting", "topiary", "topside", "torrent", "tossing", "touched", "touches",
				"touting", "towards", "toyland", "traffic", "tragedy", "trapped", "treason", "treated", "trefoil", "tresses",
				"tricked", "trigram", "trimmed", "triplet", "tripods", "tritone", "trolled", "troller", "trotted", "trustee",
				"tubular", "tumbles", "tutored", "twaddle", "tweedle", "tweeter", "twiddle", "twining", "twinkle", "twisted",
				"ugliest", "unarmed", "unasked", "unblock", "uncivil", "unfired", "unicorn", "unifies", "unknown", "unlearn",
				"unspent", "untruth", "untying", "untyped", "unwired", "updated", "upholds", "uploads", "upwards", "usually",
				"utilize", "utopian", "vacancy", "vaccine", "vagrant", "valiant", "various", "vassals", "vectors", "velvety",
				"vendors", "verbose", "verdant", "version", "vertigo", "vestige", "vetting", "vibrant", "violent", "virtues",
				"viruses", "viscous", "visions", "visuals", "voicing", "wafting", "waiting", "wallaby", "walling", "wardens",
				"warming", "warning", "warring", "warrior", "warthog", "website", "weekend", "welcome", "wettest", "whaling",
				"wheelie", "whereby", "wherein", "whether", "whitish", "whizzes", "widower", "winches", "windows", "windrow",
				"winging", "winking", "winless", "winning", "winsome", "wiretap", "wisdoms", "wishful", "wishing", "without",
				"wizards", "wobbler", "workers", "working", "workmen", "wrapper", "wreaths", "wriggle", "writing", "written",
				"xylitol"
			};
			_hasPluginConflict = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("000-the_tavern-AutogenRundown") || ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("com.Brandont.LongerCodes");
			if (_hasPluginConflict)
			{
				EOSLogger.Warning("Conflicting plugin: \"000-the_tavern-AutogenRundown\" and/or \"com.Brandont.LongerCodes\". Using default SerialGenerator settings");
			}
		}

		private static void OnBuildStart()
		{
			_random = RandomUtil.CreateSessionRandom("EOS_SerialGenerator");
			_codeWords.Clear();
			_codeWords[CodeWordLength.Three] = new ShuffledStepArray(ThreeLetterWords);
			_codeWords[CodeWordLength.Five] = new ShuffledStepArray(FiveLetterWords);
			_codeWords[CodeWordLength.Six] = new ShuffledStepArray(SixLetterWords);
			_codeWords[CodeWordLength.Seven] = new ShuffledStepArray(SevenLetterWords);
			_hardPrefixes = new ShuffledStepArray(HardCodeWordPrefixes);
		}

		public static void Init()
		{
			LevelAPI.OnBuildStart += OnBuildStart;
		}

		public static int GetUniqueSerialNo()
		{
			return SerialGenerator.GetUniqueSerialNo();
		}

		public static string GetIPAddress(bool useIPv6)
		{
			if (_hasPluginConflict || !useIPv6)
			{
				return SerialGenerator.GetIpAddress();
			}
			string[] array = new string[4]
			{
				RandomHex(256, 4608),
				RandomHex(4096, 65535),
				RandomHex(0, 511),
				RandomHex(0, 16383)
			};
			int num = array.Length;
			while (num > 1)
			{
				int num2 = _random.Next(0, num--);
				ref string reference = ref array[num2];
				ref string reference2 = ref array[num];
				string text = array[num];
				string text2 = array[num2];
				reference = text;
				reference2 = text2;
			}
			return RandomHex(8192, 16383) + "::" + string.Join(':', array);
		}

		private static string RandomHex(int min, int max)
		{
			return _random.Next(min, max).ToString("x");
		}

		public static string GetCodeWord(CodeWordLength wordLength)
		{
			if (_hasPluginConflict || !_codeWords.TryGetValue(wordLength, out var value))
			{
				return SerialGenerator.GetCodeWord();
			}
			return value.Next();
		}

		public static string GetCodeWordPrefix(bool useHardPrefixes, bool hyphenate = false)
		{
			string text = ((!_hasPluginConflict && useHardPrefixes) ? _hardPrefixes.Next() : SerialGenerator.