using System;
using System.Collections.Generic;
using System.Diagnostics;
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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using InteractiveMoonCatalogue.Compat;
using InteractiveMoonCatalogue.NetcodePatcher;
using InteractiveMoonCatalogue.UI.Application;
using InteractiveMoonCatalogue.UI.Cursor;
using InteractiveMoonCatalogue.Util;
using InteractiveTerminalAPI.Compat;
using InteractiveTerminalAPI.UI;
using InteractiveTerminalAPI.UI.Application;
using InteractiveTerminalAPI.UI.Cursor;
using InteractiveTerminalAPI.UI.Page;
using InteractiveTerminalAPI.UI.Screen;
using LethalLevelLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace WeatherProbe.Misc
{
	internal static class Metadata
	{
		public const string GUID = "com.github.WhiteSpike.InteractiveMoonCatalogue";

		public const string NAME = "Interactive Moon Catalogue";

		public const string VERSION = "1.0.1";
	}
}
namespace InteractiveMoonCatalogue
{
	[BepInPlugin("com.github.WhiteSpike.InteractiveMoonCatalogue", "Interactive Moon Catalogue", "1.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static readonly Harmony harmony = new Harmony("com.github.WhiteSpike.InteractiveMoonCatalogue");

		internal static ManualLogSource mls;

		private void Awake()
		{
			InteractiveTerminalManager.RegisterApplication<MoonCatalogueApplication>("imoons", false);
			mls = ((BaseUnityPlugin)this).Logger;
			mls.LogInfo((object)"Interactive Moon Catalogue 1.0.1 has been loaded successfully.");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "InteractiveMoonCatalogue";

		public const string PLUGIN_NAME = "ExtendDeadline";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace InteractiveMoonCatalogue.Util
{
	internal static class Tools
	{
		private static Terminal terminal;

		internal static Terminal GetTerminal()
		{
			if ((Object)(object)terminal == (Object)null)
			{
				terminal = GameObject.Find("TerminalScript").GetComponent<Terminal>();
			}
			return terminal;
		}
	}
}
namespace InteractiveMoonCatalogue.UI.Cursor
{
	internal class LevelCursorElement : CursorElement
	{
		public SelectableLevel Level { get; set; }

		public TerminalNode RouteNode { get; set; }

		public override string GetText(int availableLength)
		{
			StringBuilder sb = new StringBuilder();
			bool flag = false;
			string text;
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.IsLocked(Level))
			{
				text = "[???]";
			}
			else
			{
				text = Level.PlanetName.Substring(Level.PlanetName.IndexOf(' ') + 1) ?? "";
				if (text.Contains("Gordion"))
				{
					text += " / The Company";
				}
			}
			Terminal terminal = Tools.GetTerminal();
			int groupCredits = terminal.groupCredits;
			if (!((CursorElement)this).Active((CursorElement)(object)this))
			{
				if ((Object)(object)Level == (Object)(object)StartOfRound.Instance.currentLevel)
				{
					sb.Append("<color=#026440>");
				}
				else
				{
					sb.Append("<color=#66666666>");
				}
			}
			sb.Append(text);
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.IsLocked(Level))
			{
				sb.Append("</color>");
				return sb.ToString();
			}
			sb.Append(new string(' ', Mathf.Max(0, 14 - text.Length)));
			string previousText = "";
			if (!string.IsNullOrEmpty(Level.riskLevel) && !Level.riskLevel.Contains("Safe"))
			{
				previousText = ((!Level.riskLevel.Contains("CORRUPTION")) ? (" (" + Level.riskLevel + ")") : " (Corrupted)");
			}
			if (!string.IsNullOrEmpty(previousText))
			{
				sb.Append(previousText);
			}
			AppendPriceText(ref sb, groupCredits, ref previousText);
			AppendWeatherText(ref sb, ref previousText);
			if (!((CursorElement)this).Active((CursorElement)(object)this))
			{
				sb.Append("</color>");
			}
			return sb.ToString();
		}

		private void AppendPriceText(ref StringBuilder sb, int credits, ref string previousText)
		{
			int itemCost = RouteNode.itemCost;
			if (itemCost <= 0)
			{
				sb.Append(new string(' ', Mathf.Max(0, 9)));
				return;
			}
			sb.Append(new string(' ', Mathf.Max(0, 9 - previousText.Length)));
			if (itemCost > credits)
			{
				sb.Append("<color=#880000>");
				sb.Append(itemCost);
				sb.Append("$");
				sb.Append("</color>");
			}
			else
			{
				sb.Append(itemCost);
				sb.Append("$");
			}
			previousText = itemCost + "$";
		}

		private void AppendWeatherText(ref StringBuilder sb, ref string previousText)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			LevelWeatherType val = (Level.overrideWeather ? Level.overrideWeatherType : Level.currentWeather);
			if ((int)val != -1)
			{
				sb.Append(new string(' ', Mathf.Max(0, 9 - previousText.Length)));
				sb.Append($"({val})");
			}
		}
	}
}
namespace InteractiveMoonCatalogue.UI.Application
{
	internal class MoonCatalogueApplication : PageApplication<CursorElement>
	{
		private TerminalKeyword routeKeyword;

		protected override int GetEntriesPerPage<T>(T[] entries)
		{
			return 12;
		}

		public override void Initialization()
		{
			List<SelectableLevel> list = StartOfRound.Instance.levels.ToList();
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			levels = levels.Where((SelectableLevel x) => !x.PlanetName.Contains("Liquidation")).ToArray();
			if (LethalLevelLoaderCompat.Enabled)
			{
				LethalLevelLoaderCompat.GrabAllAvailableLevels(ref levels);
			}
			(SelectableLevel[][], BaseCursorMenu<CursorElement>[], IScreen[]) pageEntries = base.GetPageEntries<SelectableLevel>(levels);
			SelectableLevel[][] item = pageEntries.Item1;
			BaseCursorMenu<CursorElement>[] item2 = pageEntries.Item2;
			IScreen[] item3 = pageEntries.Item3;
			for (int i = 0; i < item.Length; i++)
			{
				SelectableLevel[] array = item[i];
				LevelCursorElement[] array2 = new LevelCursorElement[array.Length];
				int num = i;
				CursorElement[] array3 = (CursorElement[])(object)array2;
				item2[num] = (BaseCursorMenu<CursorElement>)(object)CursorMenu<CursorElement>.Create(0, '>', array3, new Func<CursorElement, CursorElement, int>[7] { CompareName, CompareDescendingPrice, CompareAscendingPrice, CompareDescendingDifficulty, CompareAscendingDifficulty, CompareDescendingWeather, CompareAscendingWeather });
				item2[i].sortingIndex = -1;
				BaseCursorMenu<CursorElement> val = item2[i];
				ITextElement[] elements = (ITextElement[])(object)new ITextElement[3]
				{
					(ITextElement)TextElement.Create("Select the moon you wish to route to:"),
					(ITextElement)TextElement.Create(" "),
					(ITextElement)val
				};
				item3[i] = (IScreen)(object)new BoxedOutputScreen<string, string>
				{
					Title = "Moon Catalogue",
					elements = elements,
					Input = GetCurrentSort,
					Output = (string x) => x
				};
				for (int j = 0; j < array.Length; j++)
				{
					SelectableLevel level = array[j];
					if (!((Object)(object)level == (Object)null))
					{
						TerminalNode routeNode = GetRouteNode(list.IndexOf(level));
						int num2 = j;
						LevelCursorElement obj = new LevelCursorElement
						{
							Level = level,
							RouteNode = routeNode
						};
						((CursorElement)obj).Active = (CursorElement x) => CanPurchaseRoute((LevelCursorElement)(object)x);
						((CursorElement)obj).SelectInactive = true;
						((CursorElement)obj).Action = delegate
						{
							PurchaseRoute(level, routeNode);
						};
						array2[num2] = obj;
					}
				}
			}
			base.currentPage = base.initialPage;
			((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu = base.initialPage.GetCurrentCursorMenu();
			((TerminalApplication)this).currentScreen = ((PageElement)base.initialPage).GetCurrentScreen();
		}

		private int CompareName(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			string text = levelCursorElement.Level.PlanetName.Substring(levelCursorElement.Level.PlanetName.IndexOf(' ') + 1);
			string strB = levelCursorElement2.Level.PlanetName.Substring(levelCursorElement2.Level.PlanetName.IndexOf(' ') + 1);
			return text.CompareTo(strB);
		}

		private int CompareDescendingPrice(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			int itemCost = levelCursorElement.RouteNode.itemCost;
			int itemCost2 = levelCursorElement2.RouteNode.itemCost;
			return itemCost.CompareTo(itemCost2);
		}

		private int CompareAscendingPrice(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			int itemCost = levelCursorElement.RouteNode.itemCost;
			int itemCost2 = levelCursorElement2.RouteNode.itemCost;
			return itemCost2.CompareTo(itemCost);
		}

		private int CompareDescendingDifficulty(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			if (LethalLevelLoaderCompat.Enabled)
			{
				return LethalLevelLoaderCompat.CompareDescendingDifficulty(levelCursorElement.Level, levelCursorElement2.Level);
			}
			string riskLevel = levelCursorElement.Level.riskLevel;
			string riskLevel2 = levelCursorElement2.Level.riskLevel;
			return riskLevel2.CompareTo(riskLevel);
		}

		private int CompareAscendingDifficulty(CursorElement cursor1, CursorElement cursor2)
		{
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			if (LethalLevelLoaderCompat.Enabled)
			{
				return LethalLevelLoaderCompat.CompareAscendingDifficulty(levelCursorElement.Level, levelCursorElement2.Level);
			}
			string riskLevel = levelCursorElement.Level.riskLevel;
			string riskLevel2 = levelCursorElement2.Level.riskLevel;
			return riskLevel.CompareTo(riskLevel2);
		}

		private int CompareDescendingWeather(CursorElement cursor1, CursorElement cursor2)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			LevelWeatherType val = (levelCursorElement.Level.overrideWeather ? levelCursorElement.Level.overrideWeatherType : levelCursorElement.Level.currentWeather);
			LevelWeatherType val2 = (levelCursorElement2.Level.overrideWeather ? levelCursorElement2.Level.overrideWeatherType : levelCursorElement2.Level.currentWeather);
			return ((Enum)(LevelWeatherType)(ref val)).CompareTo((object?)val2);
		}

		private int CompareAscendingWeather(CursorElement cursor1, CursorElement cursor2)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if (cursor1 == null)
			{
				return 1;
			}
			if (cursor2 == null)
			{
				return -1;
			}
			LevelCursorElement levelCursorElement = cursor1 as LevelCursorElement;
			LevelCursorElement levelCursorElement2 = cursor2 as LevelCursorElement;
			LevelWeatherType val = (levelCursorElement.Level.overrideWeather ? levelCursorElement.Level.overrideWeatherType : levelCursorElement.Level.currentWeather);
			LevelWeatherType val2 = (levelCursorElement2.Level.overrideWeather ? levelCursorElement2.Level.overrideWeatherType : levelCursorElement2.Level.currentWeather);
			return ((Enum)(LevelWeatherType)(ref val2)).CompareTo((object?)val);
		}

		private string GetCurrentSort()
		{
			int sortingIndex = ((BaseInteractiveApplication<CursorElement>)(object)this).currentCursorMenu.sortingIndex;
			if (1 == 0)
			{
			}
			string result = sortingIndex switch
			{
				0 => "Sort: Alphabetical [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				1 => "Sort: Price (Descending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				2 => "Sort: Price (Ascending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				3 => "Sort: Difficulty (Descending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				4 => "Sort: Difficulty (Ascending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				5 => "Sort: Weather (Descending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				6 => "Sort: Weather (Ascending) [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
				_ => "Sort: None [" + InputActionRebindingExtensions.GetBindingDisplayString(InputUtils_Compat.ChangeApplicationSortingKey, (DisplayStringOptions)0, (string)null) + "]", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private TerminalNode GetRouteNode(int levelIndex)
		{
			if ((Object)(object)routeKeyword == (Object)null)
			{
				routeKeyword = ((TerminalApplication)this).terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "route");
			}
			for (int i = 0; i < routeKeyword.compatibleNouns.Length; i++)
			{
				TerminalNode result = routeKeyword.compatibleNouns[i].result;
				CompatibleNoun[] terminalOptions = result.terminalOptions;
				for (int j = 0; j < terminalOptions.Length; j++)
				{
					TerminalNode result2 = terminalOptions[j].result;
					if (!((Object)(object)result2 == (Object)null) && result2.buyRerouteToMoon == levelIndex)
					{
						return result2;
					}
				}
			}
			return null;
		}

		private void PurchaseRoute(SelectableLevel level, TerminalNode routeNode)
		{
			string planetName = level.PlanetName;
			Action action = delegate
			{
				base.ResetScreen();
			};
			if (!StartOfRound.Instance.inShipPhase)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "You cannot travel to another moon while landed on one!");
				return;
			}
			if (StartOfRound.Instance.travellingToNewLevel)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "You cannot travel to another moon while travelling to one!");
				return;
			}
			if (StartOfRound.Instance.isChallengeFile)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "You cannot travel to another moon while doing a challenge moon!");
				return;
			}
			if ((Object)(object)StartOfRound.Instance.levels[routeNode.buyRerouteToMoon] == (Object)(object)StartOfRound.Instance.currentLevel)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "You have already arrived to this moon!");
				return;
			}
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.IsLocked(level))
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "You are unable to route to this moon!");
				return;
			}
			int groupCredits = ((TerminalApplication)this).terminal.groupCredits;
			if (groupCredits < routeNode.itemCost)
			{
				((InteractiveTerminalApplication<CursorElement>)(object)this).ErrorMessage(planetName, action, "Not enough credits to purchase this route!");
				return;
			}
			((InteractiveTerminalApplication<CursorElement>)(object)this).Confirm(planetName, $"Do you confirm routing to {level.PlanetName}? You will spend {routeNode.itemCost} Company Credits for the routing.", (Action)delegate
			{
				ConfirmRoute(routeNode);
			}, action, "");
		}

		private void ConfirmRoute(TerminalNode routeNode)
		{
			StartOfRound.Instance.ChangeLevelServerRpc(routeNode.buyRerouteToMoon, ((TerminalApplication)this).terminal.groupCredits - routeNode.itemCost);
			base.ResetScreen();
		}

		private bool CanPurchaseRoute(LevelCursorElement element)
		{
			if (!StartOfRound.Instance.inShipPhase || StartOfRound.Instance.travellingToNewLevel || StartOfRound.Instance.isChallengeFile || (Object)(object)StartOfRound.Instance.levels[element.RouteNode.buyRerouteToMoon] == (Object)(object)StartOfRound.Instance.currentLevel)
			{
				return false;
			}
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.IsLocked(element.Level))
			{
				return false;
			}
			int groupCredits = ((TerminalApplication)this).terminal.groupCredits;
			return element.RouteNode.itemCost <= groupCredits;
		}
	}
}
namespace InteractiveMoonCatalogue.Compat
{
	internal static class LethalLevelLoaderCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("imabatby.lethallevelloader");

		internal static void GrabAllAvailableLevels(ref SelectableLevel[] levels)
		{
			ExtendedLevel val = default(ExtendedLevel);
			levels = levels.Where((SelectableLevel x) => PatchedContent.TryGetExtendedContent(x, ref val) && !val.IsRouteHidden).ToArray();
		}

		internal static int CompareAscendingDifficulty(SelectableLevel level1, SelectableLevel level2)
		{
			ExtendedLevel val = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level1, ref val);
			ExtendedLevel val2 = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level2, ref val2);
			return val2.CalculatedDifficultyRating.CompareTo(val.CalculatedDifficultyRating);
		}

		internal static int CompareDescendingDifficulty(SelectableLevel level1, SelectableLevel level2)
		{
			ExtendedLevel val = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level1, ref val);
			ExtendedLevel val2 = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level2, ref val2);
			return val.CalculatedDifficultyRating.CompareTo(val2.CalculatedDifficultyRating);
		}

		internal static bool IsLocked(SelectableLevel level)
		{
			ExtendedLevel val = default(ExtendedLevel);
			PatchedContent.TryGetExtendedContent(level, ref val);
			return (Object)(object)val == (Object)null || val.IsRouteLocked;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace InteractiveMoonCatalogue.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}