#define DEBUG
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AdvancedCompany;
using AdvancedCompany.Boot;
using AdvancedCompany.Config;
using AdvancedCompany.Cosmetics;
using AdvancedCompany.Game;
using AdvancedCompany.Hooks.PlayerControllerB;
using AdvancedCompany.IL;
using AdvancedCompany.Lib;
using AdvancedCompany.Lib.SyncCallbacks;
using AdvancedCompany.Lib.SyncHandler;
using AdvancedCompany.Network;
using AdvancedCompany.Network.Messages;
using AdvancedCompany.Network.Sync;
using AdvancedCompany.Network.Sync.Items;
using AdvancedCompany.Objects;
using AdvancedCompany.Objects.Interfaces;
using AdvancedCompany.Patches;
using AdvancedCompany.PostProcessing;
using AdvancedCompany.Terminal.Applications;
using AdvancedCompany.UI;
using AdvancedCompany.Unity.Moons;
using AdvancedCompany.Unity.UI;
using AssetsTools.NET;
using AssetsTools.NET.Extra;
using AssetsTools.NET.Extra.Decompressors.LZ4;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Coroner;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using LZ4ps;
using LethalCompanyInputUtils.Api;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Collections.Generic;
using MoreCompany.Cosmetics;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SevenZip;
using SevenZip.Compression.LZ;
using SevenZip.Compression.LZMA;
using SevenZip.Compression.RangeCoder;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyMetadata("AdvancedCompanyIgnore", "True")]
[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)]
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;
		}
	}
}
public class BaseSettings<T> : MonoBehaviour where T : Configuration, new()
{
	public class Preset
	{
		private IConfigurationProvider Provider;

		private bool _CanBeRenamed;

		private bool _CanBeRemoved;

		private bool _CanBeSaved;

		private string _Name;

		public T Configuration;

		internal bool Selected = false;

		internal GameObject Container;

		internal GameObject SelectedBackground;

		internal TextMeshProUGUI Label;

		internal Button PresetButton;

		internal Button RemoveButton;

		internal Button RenameButton;

		public bool CanBeRenamed
		{
			get
			{
				return _CanBeRenamed;
			}
			set
			{
				_CanBeRenamed = value;
				if ((Object)(object)RenameButton != (Object)null)
				{
					((Component)RenameButton).gameObject.SetActive(_CanBeRenamed);
				}
			}
		}

		public bool CanBeRemoved
		{
			get
			{
				return _CanBeRemoved;
			}
			set
			{
				_CanBeRemoved = value;
				if ((Object)(object)RemoveButton != (Object)null)
				{
					((Component)RemoveButton).gameObject.SetActive(_CanBeRemoved);
				}
			}
		}

		public bool CanBeSaved
		{
			get
			{
				return _CanBeSaved;
			}
			set
			{
				_CanBeSaved = value;
			}
		}

		public string Name
		{
			get
			{
				return _Name;
			}
			set
			{
				_Name = value;
				if ((Object)(object)Label != (Object)null)
				{
					((TMP_Text)Label).text = _Name;
				}
			}
		}

		public Preset(IConfigurationProvider provider, string name, T configuration, bool canRemove = true, bool canRename = true, bool canBeSaved = true)
		{
			Provider = provider;
			_Name = name;
			Configuration = configuration;
			_CanBeRemoved = canRemove;
			_CanBeRenamed = canRename;
			_CanBeSaved = canBeSaved;
		}
	}

	public interface IConfigurationProvider
	{
		List<Preset> GetPresets();

		Preset GetPreset(string name);

		void PresetRenamed(Preset preset, string oldName, string newName);

		void PresetRemoved(Preset preset);

		void PresetCreated(Preset preset);

		void PresetSaved(Preset preset);

		Preset CreatePreset(string name, T configuration);
	}

	public class TestConfigurationProvider : IConfigurationProvider
	{
		private List<Preset> Presets = new List<Preset>();

		public TestConfigurationProvider()
		{
			Presets.Add(new Preset(this, "File config", new T(), canRemove: false, canRename: false));
			Presets.Add(new Preset(this, "Test 1", new T()));
			Presets.Add(new Preset(this, "Test 2", new T()));
		}

		public Preset GetPreset(string name)
		{
			for (int i = 0; i < Presets.Count; i++)
			{
				if (Presets[i].Name.Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					return Presets[i];
				}
			}
			return null;
		}

		public void PresetCreated(Preset preset)
		{
			Presets.Add(preset);
		}

		public List<Preset> GetPresets()
		{
			return Presets;
		}

		public void PresetRemoved(Preset preset)
		{
			Presets.Remove(preset);
		}

		public void PresetRenamed(Preset preset, string oldName, string newName)
		{
		}

		public void PresetSaved(Preset preset)
		{
		}

		public Preset CreatePreset(string name, T configuration)
		{
			return new Preset(this, name, configuration);
		}
	}

	public delegate void Continue(T configuration, string presetName);

	public delegate void Cancel();

	[Header("Images")]
	public Sprite TabActive;

	public Sprite TabInactive;

	[Header("Window")]
	public Transform TabContainer;

	public Transform Container;

	[Header("Presets")]
	public GameObject PresetTemplate;

	public Transform PresetContainer;

	public Button CreatePreset;

	private IConfigurationProvider PresetsProvider;

	[HideInInspector]
	public Preset SelectedPreset;

	[Header("Windows")]
	public RenamePresetWindow RenamePreset;

	public RemovePresetWindow RemovePreset;

	public ConfirmOverrideWindow ConfirmOverride;

	public NewPresetWindow NewPreset;

	[Header("Buttons")]
	public Button SaveAsNewPresetButton;

	public Button SaveButton;

	public Button ContinueButton;

	public Button CancelButton;

	[Header("Notification")]
	public GameObject NotificationObject;

	public TextMeshProUGUI NotificationText;

	[HideInInspector]
	public Continue OnContinue;

	[HideInInspector]
	public Cancel OnCancel;

	internal List<Button> Tabs = new List<Button>();

	internal List<GameObject> Containers = new List<GameObject>();

	internal T Configuration;

	private bool CreatingNew = false;

	private Preset RenamingPreset;

	private Preset DeletingPreset;

	public void SetConfiguration(IConfigurationProvider configuration)
	{
		PresetsProvider = configuration;
		Transform presetContainer = PresetContainer;
		for (int num = presetContainer.childCount - 1; num >= 0; num--)
		{
			GameObject gameObject = ((Component)presetContainer.GetChild(num)).gameObject;
			Object.Destroy((Object)(object)gameObject);
		}
		List<Preset> presets = PresetsProvider.GetPresets();
		for (int i = 0; i < presets.Count; i++)
		{
			AddPreset(presets[i]);
		}
		if (presets.Count > 0)
		{
			SelectPreset(presets[0]);
		}
	}

	public virtual void ApplyConfiguration()
	{
	}

	internal void ShowNotification(string text)
	{
		NotificationObject.SetActive(true);
		((TMP_Text)NotificationText).text = text;
		((MonoBehaviour)this).StartCoroutine(HideNotification());
	}

	internal IEnumerator HideNotification()
	{
		yield return (object)new WaitForSeconds(1f);
		NotificationObject.SetActive(false);
	}

	public virtual void Awake()
	{
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Expected O, but got Unknown
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Expected O, but got Unknown
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Expected O, but got Unknown
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Expected O, but got Unknown
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Expected O, but got Unknown
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Expected O, but got Unknown
		Configuration = new T();
		Configuration.Build();
		for (int i = 0; i < Container.childCount; i++)
		{
			Containers.Add(((Component)Container.GetChild(i)).gameObject);
		}
		for (int j = 0; j < TabContainer.childCount; j++)
		{
			Button button = ((Component)TabContainer.GetChild(j)).gameObject.GetComponent<Button>();
			GameObject container = Containers[j];
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				ChangeTab(button, container);
			});
			Tabs.Add(button);
		}
		((UnityEvent)SaveButton.onClick).AddListener((UnityAction)delegate
		{
			SelectedPreset.Configuration.CopyFrom(Configuration);
			PresetsProvider.PresetSaved(SelectedPreset);
			ShowNotification("Preset saved");
		});
		((UnityEvent)SaveAsNewPresetButton.onClick).AddListener((UnityAction)delegate
		{
			CreatingNew = false;
			NewPreset.Open("New preset");
		});
		((UnityEvent)ContinueButton.onClick).AddListener((UnityAction)delegate
		{
			if (OnContinue != null)
			{
				OnContinue(Configuration, SelectedPreset.Name);
				Close();
			}
		});
		((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
		{
			if (OnCancel != null)
			{
				OnCancel();
				Close();
			}
		});
		ConfirmOverride.OnSubmitted = delegate(string name)
		{
			Preset preset4 = PresetsProvider.GetPreset(name);
			if (preset4 != null)
			{
				Object.Destroy((Object)(object)preset4.Container);
				PresetsProvider.PresetRemoved(preset4);
			}
			if (RenamingPreset != null)
			{
				string name3 = RenamingPreset.Name;
				RenamingPreset.Name = name;
				PresetsProvider.PresetRenamed(RenamingPreset, name3, name);
				RenamingPreset = null;
				ShowNotification("Preset renamed");
			}
			else
			{
				Preset preset5 = PresetsProvider.CreatePreset(name, CreatingNew ? new T() : ((T)Configuration._Clone()));
				AddPreset(preset5);
				PresetsProvider.PresetCreated(preset5);
				ShowNotification("Preset created");
				SelectPreset(preset5);
			}
			CreatingNew = false;
		};
		RenamePreset.OnSubmitted = delegate(string name)
		{
			Preset preset3 = PresetsProvider.GetPreset(name);
			if (preset3 != null)
			{
				if (preset3.CanBeSaved)
				{
					ConfirmOverride.Open(name);
				}
			}
			else
			{
				string name2 = RenamingPreset.Name;
				RenamingPreset.Name = name;
				PresetsProvider.PresetRenamed(RenamingPreset, name2, name);
				RenamingPreset = null;
				ShowNotification("Preset renamed");
			}
		};
		RemovePreset.OnSubmitted = delegate
		{
			PresetsProvider.PresetRemoved(DeletingPreset);
			Object.Destroy((Object)(object)DeletingPreset.Container);
			ShowNotification("Preset deleted");
			List<Preset> presets = PresetsProvider.GetPresets();
			if (presets.Count > 0)
			{
				SelectPreset(presets[0]);
			}
			else
			{
				Configuration = new T();
				ApplyConfiguration();
			}
			DeletingPreset = null;
		};
		NewPreset.OnSubmitted = delegate(string name)
		{
			if (!(name == "File config"))
			{
				Preset preset = PresetsProvider.GetPreset(name);
				if (preset != null)
				{
					if (preset.CanBeSaved)
					{
						ConfirmOverride.Open(name);
					}
				}
				else
				{
					Preset preset2 = PresetsProvider.CreatePreset(name, CreatingNew ? new T() : ((T)Configuration._Clone()));
					AddPreset(preset2);
					PresetsProvider.PresetCreated(preset2);
					SelectPreset(preset2);
					ShowNotification("Preset created");
				}
			}
		};
		((UnityEvent)CreatePreset.onClick).AddListener((UnityAction)delegate
		{
			CreatingNew = true;
			NewPreset.Open("New preset");
		});
		ChangeTab(Tabs[0], Containers[0]);
	}

	public void Close()
	{
		NotificationObject.SetActive(false);
		((Component)this).gameObject.SetActive(false);
	}

	internal void AddPreset(Preset preset)
	{
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Expected O, but got Unknown
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: Expected O, but got Unknown
		//IL_017f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0189: Expected O, but got Unknown
		GameObject val = Object.Instantiate<GameObject>(PresetTemplate, PresetContainer);
		preset.Container = val;
		preset.PresetButton = val.GetComponent<Button>();
		preset.SelectedBackground = ((Component)val.transform.GetChild(0)).gameObject;
		preset.SelectedBackground.SetActive(false);
		preset.Label = ((Component)val.transform.GetChild(1)).GetComponent<TextMeshProUGUI>();
		preset.RemoveButton = ((Component)val.transform.GetChild(2)).GetComponent<Button>();
		preset.RenameButton = ((Component)val.transform.GetChild(3)).GetComponent<Button>();
		((TMP_Text)preset.Label).text = preset.Name;
		((Component)preset.RemoveButton).gameObject.SetActive(preset.CanBeRemoved);
		((Component)preset.RenameButton).gameObject.SetActive(preset.CanBeRenamed);
		((UnityEvent)preset.RenameButton.onClick).AddListener((UnityAction)delegate
		{
			RenamingPreset = preset;
			RenamePreset.Open(preset.Name);
		});
		((UnityEvent)preset.RemoveButton.onClick).AddListener((UnityAction)delegate
		{
			DeletingPreset = preset;
			RemovePreset.Open(preset.Name);
		});
		((UnityEvent)preset.PresetButton.onClick).AddListener((UnityAction)delegate
		{
			SelectPreset(preset);
		});
		val.SetActive(true);
	}

	public void SelectPreset(string name)
	{
		SelectPreset(PresetsProvider.GetPreset(name));
	}

	public void SelectPreset(Preset preset)
	{
		if (preset != null)
		{
			if (SelectedPreset != null)
			{
				SelectedPreset.SelectedBackground.SetActive(false);
			}
			preset.SelectedBackground.SetActive(true);
			SelectedPreset = preset;
			if (SelectedPreset != null)
			{
				((Component)SaveButton).gameObject.SetActive(SelectedPreset.CanBeSaved);
			}
			Configuration.CopyFrom(SelectedPreset.Configuration);
			ApplyConfiguration();
		}
	}

	internal void ChangeTab(Button toTab, GameObject container)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Expected O, but got Unknown
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < Containers.Count; i++)
		{
			Button val = Tabs[i];
			bool flag = (Object)(object)val == (Object)(object)toTab;
			Containers[i].SetActive(flag);
			Graphic targetGraphic = ((Selectable)val).targetGraphic;
			Image val2 = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val2 != null)
			{
				val2.sprite = (flag ? TabActive : TabInactive);
			}
			HorizontalLayoutGroup component = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			TextMeshProUGUI componentInChildren = ((Component)val).GetComponentInChildren<TextMeshProUGUI>();
			((Graphic)componentInChildren).color = (flag ? new Color(0.99607843f, 0.39607844f, 0.08627451f) : new Color(0.6901961f, 23f / 85f, 0.05490196f));
			((TMP_Text)componentInChildren).fontSize = (flag ? 25 : 20);
			((LayoutGroup)component).padding = (flag ? new RectOffset(20, 20, 0, 0) : new RectOffset(10, 10, 10, 0));
			RectTransform component2 = ((Component)((Selectable)val).targetGraphic).GetComponent<RectTransform>();
			component2.offsetMin = new Vector2(0f, flag ? (-0.1f) : 0f);
			component2.offsetMax = new Vector2(0f, flag ? 0f : (-9f));
		}
	}
}
public class LobbySettings : BaseSettings<LobbyConfiguration>
{
	[Header("General")]
	public ConfigTabContent GeneralTab;

	private ConfigSlider LobbySize;

	private ConfigToggle KeepOpen;

	private ConfigToggle KeepOpenOnMoon;

	[Header("Game")]
	public ConfigTabContent GameTab;

	public ConfigNumericInput StartCredits;

	public ConfigSlider GlobalValueMultiplier;

	public ConfigSlider GlobalAmountMultiplier;

	public ConfigSlider GlobalMaxPowerMultiplier;

	public ConfigToggle ActivatePortableTerminal;

	private ConfigToggle ExtendDeadline;

	public ConfigNumericInput DeadlineLength;

	private ConfigToggle SaveSuits;

	private ConfigToggle Cosmetics;

	private ConfigToggle SaveProgress;

	private ConfigToggle IndividualXP;

	private ConfigToggle ResetXP;

	private ConfigToggle DeactivateHotbar;

	private ConfigNumericInput StartXP;

	private ConfigNumericInput StartShipXP;

	private ConfigSlider XPMultiplier;

	private ConfigSlider LengthOfDay;

	[Header("Items")]
	public ConfigTabContent ItemsTab;

	private ConfigContainer ItemsContainer;

	private ConfigContainer ScrapContainer;

	private ConfigContainer UnlockablesContainer;

	private Dictionary<string, ConfigItemInput> Items = new Dictionary<string, ConfigItemInput>();

	private Dictionary<string, ConfigScrapInput> Scrap = new Dictionary<string, ConfigScrapInput>();

	private Dictionary<string, ConfigUnlockableInput> Unlockables = new Dictionary<string, ConfigUnlockableInput>();

	private ConfigSlider BulletProofVestDamageReductionAtFullHealth;

	private ConfigSlider BulletProofVestDamageReductionAtNoHealth;

	private ConfigNumericInput BulletProofVestTurretDamage;

	private ConfigNumericInput BulletProofVestShotgunDamage;

	private ConfigNumericInput BulletProofVestMaxDamage;

	private ConfigToggle BulletProofVestDestroyOnNoHealth;

	private ConfigNumericInput VisionEnhancerBatteryLife;

	private ConfigNumericInput HelmetLampBatteryLife;

	private ConfigNumericInput HeadsetBatteryLife;

	private ConfigNumericInput TacticalHelmetBatteryLife;

	private ConfigNumericInput TacticalHelmetBatteryLifeWithLight;

	private ConfigSlider FlippersSpeed;

	[Header("Perks")]
	public ConfigTabContent PerksTab;

	private Dictionary<string, ConfigPerkInput> PlayerPerks = new Dictionary<string, ConfigPerkInput>();

	private Dictionary<string, ConfigPerkInput> ShipPerks = new Dictionary<string, ConfigPerkInput>();

	[Header("Enemies")]
	public ConfigTabContent EnemiesTab;

	private Dictionary<string, ConfigEnemyInput> Enemies = new Dictionary<string, ConfigEnemyInput>();

	private ConfigContainer EnemiesContainer;

	[Header("Moons")]
	public ConfigTabContent MoonsTab;

	private ConfigToggle EnableWeatherModifiers;

	private Dictionary<string, ConfigWeatherInput> Weathers = new Dictionary<string, ConfigWeatherInput>();

	private ConfigToggle EnableMoonPrices;

	private MoonsContainer MoonsContainer;

	private Dictionary<string, ConfigMoonInput> Moons = new Dictionary<string, ConfigMoonInput>();

	public override void ApplyConfiguration()
	{
		LobbySize.UpdateValue();
		KeepOpen.UpdateValue();
		KeepOpenOnMoon.UpdateValue();
		ExtendDeadline.UpdateValue();
		SaveSuits.UpdateValue();
		Cosmetics.UpdateValue();
		IndividualXP.UpdateValue();
		ResetXP.UpdateValue();
		SaveProgress.UpdateValue();
		StartXP.UpdateValue();
		StartShipXP.UpdateValue();
		XPMultiplier.UpdateValue();
		LengthOfDay.UpdateValue();
		StartCredits.UpdateValue();
		DeactivateHotbar.UpdateValue();
		GlobalValueMultiplier.UpdateValue();
		GlobalAmountMultiplier.UpdateValue();
		GlobalMaxPowerMultiplier.UpdateValue();
		DeadlineLength.UpdateValue();
		ActivatePortableTerminal.UpdateValue();
		foreach (KeyValuePair<string, ConfigItemInput> item in Items)
		{
			if (Configuration.Items.Items.ContainsKey(item.Key))
			{
				item.Value.SetValue(Configuration.Items.Items[item.Key]);
			}
			else
			{
				item.Value.SetValue(LobbyConfiguration.AllItemsConfig.Items[item.Key]);
			}
		}
		foreach (KeyValuePair<string, ConfigUnlockableInput> unlockable in Unlockables)
		{
			if (Configuration.Items.Unlockables.ContainsKey(unlockable.Key))
			{
				unlockable.Value.SetValue(Configuration.Items.Unlockables[unlockable.Key]);
			}
			else
			{
				unlockable.Value.SetValue(LobbyConfiguration.AllUnlockablesConfig.Unlockables[unlockable.Key]);
			}
		}
		foreach (KeyValuePair<string, ConfigScrapInput> item2 in Scrap)
		{
			if (Configuration.Items.Scrap.ContainsKey(item2.Key))
			{
				item2.Value.SetValue(Configuration.Items.Scrap[item2.Key]);
			}
			else
			{
				item2.Value.SetValue(LobbyConfiguration.AllScrapConfig.Items[item2.Key]);
			}
		}
		foreach (KeyValuePair<string, ConfigEnemyInput> enemy in Enemies)
		{
			if (Configuration.Enemies.Enemies.ContainsKey(enemy.Key))
			{
				enemy.Value.SetValue(Configuration.Enemies.Enemies[enemy.Key]);
			}
			else
			{
				enemy.Value.SetValue(LobbyConfiguration.AllEnemiesConfig.Enemies[enemy.Key]);
			}
		}
		VisionEnhancerBatteryLife.UpdateValue();
		BulletProofVestDestroyOnNoHealth.UpdateValue();
		BulletProofVestDamageReductionAtFullHealth.UpdateValue();
		BulletProofVestDamageReductionAtNoHealth.UpdateValue();
		BulletProofVestTurretDamage.UpdateValue();
		BulletProofVestShotgunDamage.UpdateValue();
		BulletProofVestMaxDamage.UpdateValue();
		HelmetLampBatteryLife.UpdateValue();
		HeadsetBatteryLife.UpdateValue();
		TacticalHelmetBatteryLife.UpdateValue();
		TacticalHelmetBatteryLifeWithLight.UpdateValue();
		FlippersSpeed.UpdateValue();
		PlayerPerks["SprintSpeed"].UpdateValue();
		PlayerPerks["JumpHeight"].UpdateValue();
		PlayerPerks["JumpStamina"].UpdateValue();
		PlayerPerks["SprintStamina"].UpdateValue();
		PlayerPerks["StaminaRegen"].UpdateValue();
		PlayerPerks["FallDamage"].UpdateValue();
		PlayerPerks["Damage"].UpdateValue();
		PlayerPerks["Weight"].UpdateValue();
		PlayerPerks["WeightSpeed"].UpdateValue();
		PlayerPerks["DealDamage"].UpdateValue();
		PlayerPerks["ClimbingSpeed"].UpdateValue();
		PlayerPerks["InventorySlots"].UpdateValue();
		ShipPerks["ScanDistance"].UpdateValue();
		ShipPerks["ExtraBattery"].UpdateValue();
		ShipPerks["ExtendDeadlineDiscount"].UpdateValue();
		ShipPerks["LandingSpeed"].UpdateValue();
		ShipPerks["DeliverySpeed"].UpdateValue();
		ShipPerks["SaveLoot"].UpdateValue();
		ShipPerks["TravelDiscount"].UpdateValue();
		Weathers["Clear"].UpdateValue();
		Weathers["Foggy"].UpdateValue();
		Weathers["Rainy"].UpdateValue();
		Weathers["Flooded"].UpdateValue();
		Weathers["Stormy"].UpdateValue();
		Weathers["Eclipsed"].UpdateValue();
		MoonsContainer.UpdateValues();
	}

	public override void Awake()
	{
		base.Awake();
		ConfigContainer configContainer = GeneralTab.AddContainer("Lobby", "");
		LobbySize = configContainer.AddSlider(Configuration.Lobby.Field("LobbySize"), "Lobby size");
		ConfigContainer configContainer2 = GeneralTab.AddContainer("Keep open - EXPERIMENTAL", "When activated your Steam lobby will be kept open and joinable when you are in orbit. You can also activate to allow joining of players while on a moon. This will put the players into spectator mode.");
		KeepOpen = configContainer2.AddToggle(Configuration.Lobby.Field("KeepOpen"), "Enabled");
		KeepOpenOnMoon = configContainer2.AddToggle(Configuration.Lobby.Field("KeepOpenOnMoon"), "Allow when landed");
		ConfigContainer configContainer3 = GameTab.AddContainer("Day settings", "Settings to change how days behave.");
		LengthOfDay = configContainer3.AddSlider(Configuration.General.Field("DayLength"), "Length of day");
		ConfigContainer configContainer4 = GameTab.AddContainer("Start settings", "Settings to change how a round starts.");
		StartCredits = configContainer4.AddNumericInput(Configuration.General.Field("StartCredits"), "Start credits", "");
		ConfigContainer configContainer5 = GameTab.AddContainer("Global multipliers", "Settings to change how much scrap spawns and how valueable it is and other stuff like enemy max power.");
		GlobalValueMultiplier = configContainer5.AddSlider(Configuration.General.Field("GlobalScrapValueMultiplier"), "Value");
		GlobalAmountMultiplier = configContainer5.AddSlider(Configuration.General.Field("GlobalScrapAmountMultiplier"), "Amount");
		GlobalMaxPowerMultiplier = configContainer5.AddSlider(Configuration.General.Field("GlobalMaxPowerMultiplier"), "Max enemy power");
		ConfigContainer configContainer6 = GameTab.AddContainer("Deadline", "The extend deadline option adds a command to your portable terminal to extend your deadline once per quota. You can also change the length of the deadline in general. Changes to this variable only takes effect when starting a new game or quota");
		ExtendDeadline = configContainer6.AddToggle(Configuration.General.Field("EnableExtendDeadline"), "Enabled");
		DeadlineLength = configContainer6.AddNumericInput(Configuration.General.Field("DeadlineLength"), "Length of deadline", "");
		ConfigContainer configContainer7 = GameTab.AddContainer("Save suits after being fired", "When activated will save your suits when you are getting fired.");
		SaveSuits = configContainer7.AddToggle(Configuration.General.Field("SaveSuitsAfterDeath"), "Enabled");
		ConfigContainer configContainer8 = GameTab.AddContainer("Enable cosmetics", "When activated players will have the ability to wear cosmetics.");
		Cosmetics = configContainer8.AddToggle(Configuration.General.Field("EnableCosmetics"), "Enabled");
		ConfigContainer configContainer9 = GameTab.AddContainer("Portable terminal", "PLEASE NOTE: If you deactivate the portable terminal you won't have access to perks as well. There is NO replacement!");
		ActivatePortableTerminal = configContainer9.AddToggle(Configuration.General.Field("ActivatePortableTerminal"), "Enabled");
		ConfigContainer configContainer10 = GameTab.AddContainer("Save progress", "When deactivated allows you to customize starting XP and XP multipliers. Progress for all players will be saved in the hosts save file and reset when not meeting the quota.");
		SaveProgress = configContainer10.AddToggle(Configuration.General.Field("SaveProgress"), "Enabled");
		configContainer10.AddEmpty();
		IndividualXP = configContainer10.AddToggle(Configuration.General.Field("IndividualXP"), "Individual XP");
		ResetXP = configContainer10.AddToggle(Configuration.General.Field("ResetXP"), "Reset XP");
		StartXP = configContainer10.AddNumericInput(Configuration.General.Field("StartingXP"), "Start XP", "XP", 60f);
		StartShipXP = configContainer10.AddNumericInput(Configuration.General.Field("StartingShipXP"), "Start ship XP", "XP", 60f);
		XPMultiplier = configContainer10.AddSlider(Configuration.General.Field("XPMultiplier"), "XP multiplier");
		ConfigContainer configContainer11 = GameTab.AddContainer("Deactivate hotbar", "WARNING: If you enable this setting, AdvancedCompany won't touch the hotbar and inventories at all. This means that the inventory perk gets auto deactivated, all equippable items, including cursed items, will get forcefully deactivated, the energy bars are removed, customization of the hotbar is removed, there wont be any hotkeys, neither flashlight nor quick access, added and no inventory fixes like flashlight fixes. This mode is experimental and there won't be any support for it whatsoever. If I see you using it and creating a GitHub issue relating to this mode it will get auto closed. Activating this option might result in unwanted results as the hotbar changes are a core function of AdvancedCompany. Spawning in and equipping any equipment item might break your game in unexpected ways.");
		DeactivateHotbar = configContainer11.AddToggle(Configuration.General.Field("DeactivateHotbar"), "Deactivate");
		ItemsContainer = ItemsTab.AddItemContainer("Store items", "Here you can configure store items and if they should be activated.");
		foreach (KeyValuePair<string, LobbyConfiguration.ItemConfig> item in Configuration.Items.Items)
		{
			Items[item.Key] = ItemsContainer.AddItem(item.Value, item.Key);
		}
		UnlockablesContainer = ItemsTab.AddUnlockableContainer("Unlockables", "Here you can configure unlockables and if they should be purchaseable.");
		foreach (KeyValuePair<string, LobbyConfiguration.UnlockableConfig> unlockable in Configuration.Items.Unlockables)
		{
			Unlockables[unlockable.Key] = UnlockablesContainer.AddUnlockable(unlockable.Value, unlockable.Key);
		}
		ScrapContainer = ItemsTab.AddScrapContainer("Scrap items", "Here you can configure scrap items and if they should spawn.");
		foreach (KeyValuePair<string, LobbyConfiguration.ScrapConfig> item2 in Configuration.Items.Scrap)
		{
			Scrap[item2.Key] = ScrapContainer.AddScrap(item2.Value, item2.Key);
		}
		EnemiesContainer = EnemiesTab.AddEnemyContainer("Enemies", "Here you can configure enemies power levels and if they should spawn at all.");
		foreach (KeyValuePair<string, LobbyConfiguration.EnemyConfig> enemy in Configuration.Enemies.Enemies)
		{
			Enemies[enemy.Key] = EnemiesContainer.AddEnemy(enemy.Value, enemy.Key);
		}
		ConfigContainer configContainer12 = ItemsTab.AddContainer("Vision enhancer", "Here you can change parameters for the vision enhancer.");
		VisionEnhancerBatteryLife = configContainer12.AddNumericInput(Configuration.Items.VisionEnhancer.Field("BatteryTime"), "Battery life", "secs", 60f);
		ConfigContainer configContainer13 = ItemsTab.AddContainer("Bulletproof vest", "Here you can change parameters for the bulletproof vest.");
		BulletProofVestMaxDamage = configContainer13.AddNumericInput(Configuration.Items.BulletProofVest.Field("MaxDamage"), "Max damage", "HP", 60f);
		BulletProofVestDestroyOnNoHealth = configContainer13.AddToggle(Configuration.Items.BulletProofVest.Field("DestroyAtNoHealth"), "Destroy on no health");
		BulletProofVestTurretDamage = configContainer13.AddNumericInput(Configuration.Items.BulletProofVest.Field("TurretDamage"), "Turret damage", "HP", 60f);
		BulletProofVestShotgunDamage = configContainer13.AddNumericInput(Configuration.Items.BulletProofVest.Field("ShotgunDamage"), "Shotgun damage", "HP", 60f);
		BulletProofVestDamageReductionAtFullHealth = configContainer13.AddSlider(Configuration.Items.BulletProofVest.Field("DamageReductionAtFullHealth"), "Damage reduction at full health");
		BulletProofVestDamageReductionAtNoHealth = configContainer13.AddSlider(Configuration.Items.BulletProofVest.Field("DamageReductionAtNoHealth"), "Damage reduction at no health");
		ConfigContainer configContainer14 = ItemsTab.AddContainer("Helmet lamp", "Here you can change parameters for the helmet lamp.");
		HelmetLampBatteryLife = configContainer14.AddNumericInput(Configuration.Items.HelmetLamp.Field("BatteryTime"), "Battery life", "secs", 60f);
		ConfigContainer configContainer15 = ItemsTab.AddContainer("Headset", "Here you can change parameters for the headset.");
		HeadsetBatteryLife = configContainer15.AddNumericInput(Configuration.Items.Headset.Field("BatteryTime"), "Battery life", "secs", 60f);
		ConfigContainer configContainer16 = ItemsTab.AddContainer("Tactical helmet", "Here you can change parameters for the tactical helmet.");
		TacticalHelmetBatteryLife = configContainer16.AddNumericInput(Configuration.Items.TacticalHelmet.Field("BatteryTime"), "Battery life", "secs", 60f);
		TacticalHelmetBatteryLifeWithLight = configContainer16.AddNumericInput(Configuration.Items.TacticalHelmet.Field("BatteryTimeWithLight"), "Battery life with light", "secs", 60f);
		ConfigContainer configContainer17 = ItemsTab.AddContainer("Flippers", "Here you can change parameters for the flippers.");
		FlippersSpeed = configContainer17.AddSlider(Configuration.Items.Flippers.Field("Speed"), "Speed");
		ConfigContainer configContainer18 = PerksTab.AddPerkContainer("Player perks", "Player perks can be purchased by every player individually and will only have an effect for the player who've bought them.");
		PlayerPerks["SprintSpeed"] = configContainer18.AddPerk(Configuration.PlayerPerks.SprintSpeed, "Sprint speed");
		PlayerPerks["JumpHeight"] = configContainer18.AddPerk(Configuration.PlayerPerks.JumpHeight, "Jump height");
		PlayerPerks["JumpStamina"] = configContainer18.AddPerk(Configuration.PlayerPerks.JumpStamina, "Jump stamina");
		PlayerPerks["SprintStamina"] = configContainer18.AddPerk(Configuration.PlayerPerks.SprintStamina, "Sprint stamina");
		PlayerPerks["StaminaRegen"] = configContainer18.AddPerk(Configuration.PlayerPerks.StaminaRegen, "Stamina regen");
		PlayerPerks["FallDamage"] = configContainer18.AddPerk(Configuration.PlayerPerks.FallDamage, "Fall damage");
		PlayerPerks["Damage"] = configContainer18.AddPerk(Configuration.PlayerPerks.Damage, "Damage");
		PlayerPerks["Weight"] = configContainer18.AddPerk(Configuration.PlayerPerks.Weight, "Weight");
		PlayerPerks["WeightSpeed"] = configContainer18.AddPerk(Configuration.PlayerPerks.WeightSpeed, "Weight speed");
		PlayerPerks["DealDamage"] = configContainer18.AddPerk(Configuration.PlayerPerks.DealDamage, "Critical strike chance");
		PlayerPerks["ClimbingSpeed"] = configContainer18.AddPerk(Configuration.PlayerPerks.ClimbingSpeed, "Climbing speed");
		PlayerPerks["InventorySlots"] = configContainer18.AddPerk(Configuration.PlayerPerks.InventorySlots, "Inventory slots");
		ConfigContainer configContainer19 = PerksTab.AddPerkContainer("Ship perks", "Ship perks can be purchased by every player for the whole crew and they will have an effect for the entire team.");
		ShipPerks["ScanDistance"] = configContainer19.AddPerk(Configuration.ShipPerks.ScanDistance, "Scan distance");
		ShipPerks["ExtraBattery"] = configContainer19.AddPerk(Configuration.ShipPerks.ExtraBattery, "Extra battery");
		ShipPerks["ExtendDeadlineDiscount"] = configContainer19.AddPerk(Configuration.ShipPerks.ExtendDeadlineDiscount, "Extend deadline discount");
		ShipPerks["LandingSpeed"] = configContainer19.AddPerk(Configuration.ShipPerks.LandingSpeed, "Landing speed");
		ShipPerks["DeliverySpeed"] = configContainer19.AddPerk(Configuration.ShipPerks.DeliverySpeed, "Delivery speed");
		ShipPerks["SaveLoot"] = configContainer19.AddPerk(Configuration.ShipPerks.SaveLoot, "Save loot");
		ShipPerks["TravelDiscount"] = configContainer19.AddPerk(Configuration.ShipPerks.TravelDiscount, "Travel discount");
		MoonsContainer = MoonsTab.AddMoonContainer("Moons", "Here you can configure moons, their loot tables and enemy spawn table. If a moon is missing from the list, start a game once and come back here after that. They should show up then.", Configuration.Moons);
		ConfigContainer configContainer20 = MoonsTab.AddContainer("Weather modifiers", "Here you can modify the scrap value and amount present on moons during specific weather conditions.");
		ConfigContainer configContainer21 = MoonsTab.AddWeatherContainer(null, null);
		Weathers["Clear"] = configContainer21.AddWeather(Configuration.Moons.ClearWeather, "Clear");
		Weathers["Foggy"] = configContainer21.AddWeather(Configuration.Moons.FoggyWeather, "Foggy");
		Weathers["Rainy"] = configContainer21.AddWeather(Configuration.Moons.RainyWeather, "Rainy");
		Weathers["Flooded"] = configContainer21.AddWeather(Configuration.Moons.FloodedWeather, "Flooded");
		Weathers["Stormy"] = configContainer21.AddWeather(Configuration.Moons.StormyWeather, "Stormy");
		Weathers["Eclipsed"] = configContainer21.AddWeather(Configuration.Moons.EclipsedWeather, "Eclipsed");
	}
}
public class PlayerSettings : BaseSettings<PlayerConfiguration>
{
	public interface ICosmeticProvider
	{
		List<Cosmetic> GetCosmetics();
	}

	public class TestCosmeticProvider : ICosmeticProvider
	{
		private List<Cosmetic> Cosmetics;

		public TestCosmeticProvider()
		{
			Cosmetics = new List<Cosmetic>();
			List<CosmeticInstance> list = CosmeticDatabase.AllCosmetics.Values.ToList();
			for (int i = 0; i < list.Count; i++)
			{
				Cosmetics.Add(new Cosmetic
				{
					MoreCompanyInstance = list[i],
					Icon = list[i].icon
				});
			}
			Cosmetics.OrderBy((Cosmetic v) => v.MoreCompanyInstance.cosmeticId);
		}

		public List<Cosmetic> GetCosmetics()
		{
			return Cosmetics;
		}
	}

	public class Cosmetic
	{
		public Texture2D Icon;

		public CosmeticInstance MoreCompanyInstance;

		internal Image SelectedBackground;

		internal Button Button;

		public void Unselect()
		{
			((Behaviour)SelectedBackground).enabled = false;
		}

		public void Select()
		{
			((Behaviour)SelectedBackground).enabled = true;
		}
	}

	[Header("File")]
	public ConfigTabContent FileTabContent;

	private ConfigToggle SaveInProfile;

	[Header("Hotbar")]
	public ConfigTabContent HotbarTabContent;

	private ConfigSlider HotbarAlpha;

	private ConfigSlider HotbarScale;

	private ConfigSlider HotbarSpacing;

	private ConfigSlider HotbarBorderWidth;

	private ConfigSlider HotbarY;

	private ConfigToggle InvertScroll;

	[Header("Graphics")]
	public ConfigTabContent GraphicsTabContent;

	private ConfigSlider MusicVolume;

	private ConfigSlider VisionEnhancerBrightness;

	[Header("Compability")]
	public ConfigTabContent CompabilityTabContent;

	private ConfigToggle DisableMusic;

	private ConfigToggle HideEquipment;

	private ConfigToggle HideCosmetics;

	private ConfigToggle AnimationsCompability;

	[Header("Cosmetics")]
	public GameObject IconTemplate;

	public Transform CosmeticTabsContainer;

	public Transform CosmeticContainer;

	public RawImage PlayerCamera;

	public DressUpDrag PlayerDragHandler;

	private float DressUpRotation;

	private float DressUpHeight;

	public Transform DressUpTarget;

	public Camera DressUpCamera;

	public Transform DressUpPlayer;

	private Transform DressUpSpine004;

	private Transform DressUpSpine003;

	private Transform DressUpArmRLower;

	private Transform DressUpSpine;

	private Transform DressUpShinL;

	private Transform DressUpShinR;

	private List<Button> CosmeticTabs = new List<Button>();

	private List<GameObject> CosmeticContainers = new List<GameObject>();

	private ICosmeticProvider CosmeticsProvider;

	private Dictionary<CosmeticType, Dictionary<string, GameObject>> SpawnedCosmetics = new Dictionary<CosmeticType, Dictionary<string, GameObject>>();

	public override void ApplyConfiguration()
	{
		RemoveAllCosmetics();
		HotbarAlpha.UpdateValue();
		HotbarScale.UpdateValue();
		HotbarBorderWidth.UpdateValue();
		HotbarSpacing.UpdateValue();
		HotbarY.UpdateValue();
		InvertScroll.UpdateValue();
		SaveInProfile.UpdateValue();
		MusicVolume.UpdateValue();
		VisionEnhancerBrightness.UpdateValue();
		DisableMusic.UpdateValue();
		HideCosmetics.UpdateValue();
		HideEquipment.UpdateValue();
		AnimationsCompability.UpdateValue();
		if (CosmeticsProvider == null)
		{
			return;
		}
		List<Cosmetic> cosmetics = CosmeticsProvider.GetCosmetics();
		foreach (Cosmetic item in cosmetics)
		{
			item.Unselect();
		}
		foreach (string activatedCosmetic in Configuration.Cosmetics.ActivatedCosmetics)
		{
			for (int i = 0; i < cosmetics.Count; i++)
			{
				if ((Object)(object)cosmetics[i].MoreCompanyInstance != (Object)null && cosmetics[i].MoreCompanyInstance.cosmeticId == activatedCosmetic)
				{
					cosmetics[i].Select();
					AddCosmetic(cosmetics[i]);
					break;
				}
			}
		}
	}

	public void SetCosmeticsProvider(ICosmeticProvider provider)
	{
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_021e: Expected O, but got Unknown
		CosmeticsProvider = provider;
		List<Cosmetic> cosmetics = CosmeticsProvider.GetCosmetics();
		foreach (GameObject cosmeticContainer in CosmeticContainers)
		{
			int childCount = cosmeticContainer.transform.childCount;
			for (int num = childCount - 1; num >= 0; num--)
			{
				Transform child = cosmeticContainer.transform.GetChild(num);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
		}
		for (int i = 0; i < cosmetics.Count; i++)
		{
			Cosmetic cosmetic = cosmetics[i];
			if ((Object)(object)cosmetic.MoreCompanyInstance != (Object)null)
			{
				GameObject val = CosmeticContainers[0];
				if (cosmetic.MoreCompanyInstance.cosmeticType == CosmeticType.CHEST)
				{
					val = CosmeticContainers[1];
				}
				else if (cosmetic.MoreCompanyInstance.cosmeticType == CosmeticType.HIP)
				{
					val = CosmeticContainers[2];
				}
				else if (cosmetic.MoreCompanyInstance.cosmeticType == CosmeticType.R_LOWER_ARM)
				{
					val = CosmeticContainers[3];
				}
				else if (cosmetic.MoreCompanyInstance.cosmeticType == CosmeticType.L_SHIN)
				{
					val = CosmeticContainers[4];
				}
				else if (cosmetic.MoreCompanyInstance.cosmeticType == CosmeticType.R_SHIN)
				{
					val = CosmeticContainers[5];
				}
				GameObject val2 = Object.Instantiate<GameObject>(IconTemplate, val.transform);
				((Behaviour)val2.GetComponent<Image>()).enabled = true;
				cosmetics[i].Button = val2.GetComponent<Button>();
				((Behaviour)cosmetics[i].Button).enabled = true;
				((UnityEvent)cosmetics[i].Button.onClick).AddListener((UnityAction)delegate
				{
					ChangeCosmetic(cosmetic);
				});
				cosmetics[i].SelectedBackground = ((Component)val2.transform.GetChild(0)).GetComponent<Image>();
				((Behaviour)cosmetics[i].SelectedBackground).enabled = false;
				RawImage component = ((Component)val2.transform.GetChild(2)).GetComponent<RawImage>();
				component.texture = (Texture)(object)cosmetic.MoreCompanyInstance.icon;
				((Behaviour)component).enabled = true;
				val2.SetActive(true);
			}
		}
		if (Configuration == null)
		{
			return;
		}
		foreach (Cosmetic item in cosmetics)
		{
			item.Unselect();
		}
		foreach (string activatedCosmetic in Configuration.Cosmetics.ActivatedCosmetics)
		{
			for (int j = 0; j < cosmetics.Count; j++)
			{
				if ((Object)(object)cosmetics[j].MoreCompanyInstance != (Object)null && cosmetics[j].MoreCompanyInstance.cosmeticId == activatedCosmetic)
				{
					cosmetics[j].Select();
					AddCosmetic(cosmetics[j]);
					break;
				}
			}
		}
	}

	private void AddCosmetic(Cosmetic cosmetic)
	{
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		if (!SpawnedCosmetics.ContainsKey(cosmetic.MoreCompanyInstance.cosmeticType))
		{
			SpawnedCosmetics.Add(cosmetic.MoreCompanyInstance.cosmeticType, new Dictionary<string, GameObject>());
		}
		Dictionary<string, GameObject> dictionary = SpawnedCosmetics[cosmetic.MoreCompanyInstance.cosmeticType];
		if (!dictionary.ContainsKey(cosmetic.MoreCompanyInstance.cosmeticId))
		{
			Transform val = SelectBone(cosmetic.MoreCompanyInstance.cosmeticType);
			GameObject val2 = Object.Instantiate<GameObject>(((Component)cosmetic.MoreCompanyInstance).gameObject);
			val2.transform.position = ((Component)val).transform.position;
			val2.transform.rotation = ((Component)val).transform.rotation;
			Transform[] componentsInChildren = val2.GetComponentsInChildren<Transform>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Component)componentsInChildren[i]).gameObject.layer = 31;
			}
			val2.transform.parent = val;
			Transform transform = val2.transform;
			transform.localScale *= DressUpPlayer.parent.lossyScale.x * 0.38f;
			val2.layer = 31;
			dictionary.Add(cosmetic.MoreCompanyInstance.cosmeticId, val2);
		}
	}

	private void RemoveAllCosmetics()
	{
		foreach (KeyValuePair<CosmeticType, Dictionary<string, GameObject>> spawnedCosmetic in SpawnedCosmetics)
		{
			foreach (KeyValuePair<string, GameObject> item in spawnedCosmetic.Value)
			{
				Object.Destroy((Object)(object)item.Value);
			}
		}
		SpawnedCosmetics = new Dictionary<CosmeticType, Dictionary<string, GameObject>>();
	}

	private void RemoveCosmetic(Cosmetic cosmetic)
	{
		if (SpawnedCosmetics.ContainsKey(cosmetic.MoreCompanyInstance.cosmeticType))
		{
			Dictionary<string, GameObject> dictionary = SpawnedCosmetics[cosmetic.MoreCompanyInstance.cosmeticType];
			if (dictionary.ContainsKey(cosmetic.MoreCompanyInstance.cosmeticId))
			{
				Object.Destroy((Object)(object)dictionary[cosmetic.MoreCompanyInstance.cosmeticId]);
				dictionary.Remove(cosmetic.MoreCompanyInstance.cosmeticId);
			}
		}
	}

	private void ChangeCosmetic(Cosmetic cosmetic)
	{
		if (Configuration.Cosmetics.ActivatedCosmetics == null)
		{
			Configuration.Cosmetics.ActivatedCosmetics = new List<string>();
		}
		if (Configuration.Cosmetics.ActivatedCosmetics.Contains(cosmetic.MoreCompanyInstance.cosmeticId))
		{
			cosmetic.Unselect();
			Configuration.Cosmetics.ActivatedCosmetics.Remove(cosmetic.MoreCompanyInstance.cosmeticId);
			RemoveCosmetic(cosmetic);
			return;
		}
		Configuration.Cosmetics.ActivatedCosmetics.Add(cosmetic.MoreCompanyInstance.cosmeticId);
		if (!SpawnedCosmetics.ContainsKey(cosmetic.MoreCompanyInstance.cosmeticType))
		{
			SpawnedCosmetics.Add(cosmetic.MoreCompanyInstance.cosmeticType, new Dictionary<string, GameObject>());
		}
		cosmetic.Select();
		AddCosmetic(cosmetic);
	}

	private Transform SelectBone(CosmeticType type)
	{
		return (Transform)(type switch
		{
			CosmeticType.HAT => DressUpSpine004, 
			CosmeticType.CHEST => DressUpSpine003, 
			CosmeticType.HIP => DressUpSpine, 
			CosmeticType.R_LOWER_ARM => DressUpArmRLower, 
			CosmeticType.L_SHIN => DressUpShinL, 
			CosmeticType.R_SHIN => DressUpShinR, 
			_ => null, 
		});
	}

	public override void Awake()
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Expected O, but got Unknown
		//IL_047f: Unknown result type (might be due to invalid IL or missing references)
		//IL_049f: Unknown result type (might be due to invalid IL or missing references)
		//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
		base.Awake();
		for (int i = 0; i < CosmeticContainer.childCount; i++)
		{
			CosmeticContainers.Add(((Component)CosmeticContainer.GetChild(i)).gameObject);
		}
		for (int j = 0; j < CosmeticTabsContainer.childCount; j++)
		{
			Button button = ((Component)CosmeticTabsContainer.GetChild(j)).gameObject.GetComponent<Button>();
			GameObject container = CosmeticContainers[j];
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				ChangeCosmeticTab(button, container);
			});
			CosmeticTabs.Add(button);
		}
		Transform child = ((Component)DressUpPlayer).transform.GetChild(0).GetChild(1);
		DressUpSpine = child.Find("spine");
		Transform val = DressUpSpine.Find("thigh.L");
		DressUpShinL = val.Find("shin.L");
		Transform val2 = DressUpSpine.Find("thigh.R");
		DressUpShinR = val2.Find("shin.R");
		Transform val3 = DressUpSpine.Find("spine.001");
		Transform val4 = val3.Find("spine.002");
		DressUpSpine003 = val4.Find("spine.003");
		DressUpSpine004 = DressUpSpine003.Find("spine.004");
		Transform val5 = DressUpSpine003.Find("shoulder.R");
		Transform val6 = val5.Find("arm.R_upper");
		DressUpArmRLower = val6.Find("arm.R_lower");
		PresetTemplate.SetActive(false);
		IconTemplate.SetActive(false);
		ConfigContainer configContainer = HotbarTabContent.AddContainer("Hotbar", "Here you can customize the appearance of the hotbar.");
		HotbarAlpha = configContainer.AddSlider(Configuration.Hotbar.Field("HotbarAlpha"), "Hotbar alpha");
		HotbarScale = configContainer.AddSlider(Configuration.Hotbar.Field("HotbarScale"), "Hotbar scale");
		HotbarBorderWidth = configContainer.AddSlider(Configuration.Hotbar.Field("HotbarBorderWidth"), "Hotbar border width");
		HotbarSpacing = configContainer.AddSlider(Configuration.Hotbar.Field("HotbarSpacing"), "Hotbar spacing");
		HotbarY = configContainer.AddSlider(Configuration.Hotbar.Field("HotbarY"), "Hotbar Y pos");
		InvertScroll = configContainer.AddToggle(Configuration.Hotbar.Field("InvertScroll"), "Invert scroll");
		configContainer = FileTabContent.AddContainer("Save in profile", "When activated your progression file will be saved in your profile folder.");
		SaveInProfile = configContainer.AddToggle(Configuration.File.Field("SaveInProfile"), "Enable");
		ConfigContainer configContainer2 = GraphicsTabContent.AddContainer("Audio", "Change audio volume.");
		MusicVolume = configContainer2.AddSlider(Configuration.Graphics.Field("MusicVolume"), "Music volume");
		ConfigContainer configContainer3 = GraphicsTabContent.AddContainer("Vision enhancer", "Change how the vision enhancer looks.");
		VisionEnhancerBrightness = configContainer3.AddSlider(Configuration.Graphics.Field("VisionEnhancerBrightness"), "Brightness");
		ConfigContainer configContainer4 = CompabilityTabContent.AddContainer("Compatibility", "Here you can change certain client side functionality for compatibility reasons. Those settings will mostly only take effect when applied BEFORE joining a game.");
		DisableMusic = configContainer4.AddToggle(Configuration.Compability.Field("DisableMusic"), "Disable music");
		HideCosmetics = configContainer4.AddToggle(Configuration.Compability.Field("HideCosmetics"), "Hide cosmetics");
		HideEquipment = configContainer4.AddToggle(Configuration.Compability.Field("HideEquipment"), "Hide equipment");
		AnimationsCompability = configContainer4.AddToggle(Configuration.Compability.Field("AnimationsCompability"), "Animation compability mode");
		((Component)DressUpPlayer).transform.parent.localScale = new Vector3(1f / ((Component)DressUpPlayer).transform.parent.lossyScale.x, 1f / ((Component)DressUpPlayer).transform.parent.lossyScale.y, 1f / ((Component)DressUpPlayer).transform.parent.lossyScale.z);
	}

	internal void ChangeCosmeticTab(Button toTab, GameObject container)
	{
		//IL_00a4: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		for (int i = 0; i < CosmeticContainers.Count; i++)
		{
			Button val = CosmeticTabs[i];
			bool flag = (Object)(object)val == (Object)(object)toTab;
			CosmeticContainers[i].SetActive(flag);
			Graphic targetGraphic = ((Selectable)val).targetGraphic;
			Image val2 = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val2 != null)
			{
				val2.sprite = (flag ? TabActive : TabInactive);
			}
			HorizontalLayoutGroup component = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			Image component2 = ((Component)((Component)val).transform.GetChild(1)).GetComponent<Image>();
			((Graphic)component2).color = (flag ? new Color(0.99607843f, 0.39607844f, 0.08627451f) : new Color(0.6901961f, 23f / 85f, 0.05490196f));
			((LayoutGroup)component).padding = (flag ? new RectOffset(5, 5, 5, 0) : new RectOffset(5, 5, 5, 0));
		}
	}

	public void Update()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		if (PlayerDragHandler.Delta != Vector2.zero)
		{
			DressUpRotation += PlayerDragHandler.Delta.x * 0.2f;
			DressUpHeight += PlayerDragHandler.Delta.y * 0.01f;
		}
		DressUpRotation = Mathf.Clamp((DressUpRotation + 360f) % 360f, 0f, 360f);
		DressUpHeight = Mathf.Clamp(DressUpHeight, -0.5f, 1.5f);
		((Component)DressUpCamera).transform.localPosition = new Vector3(0f, 1f + DressUpHeight, 4f);
		((Component)DressUpCamera).transform.LookAt(DressUpTarget);
		((Component)DressUpPlayer).transform.localRotation = Quaternion.Euler(new Vector3(0f, DressUpRotation, 0f));
	}
}
namespace SevenZip
{
	internal class CRC
	{
		public static readonly uint[] Table;

		private uint _value = uint.MaxValue;

		static CRC()
		{
			Table = new uint[256];
			for (uint num = 0u; num < 256; num++)
			{
				uint num2 = num;
				for (int i = 0; i < 8; i++)
				{
					num2 = (((num2 & 1) == 0) ? (num2 >> 1) : ((num2 >> 1) ^ 0xEDB88320u));
				}
				Table[num] = num2;
			}
		}

		public void Init()
		{
			_value = uint.MaxValue;
		}

		public void UpdateByte(byte b)
		{
			_value = Table[(byte)_value ^ b] ^ (_value >> 8);
		}

		public void Update(byte[] data, uint offset, uint size)
		{
			for (uint num = 0u; num < size; num++)
			{
				_value = Table[(byte)_value ^ data[offset + num]] ^ (_value >> 8);
			}
		}

		public uint GetDigest()
		{
			return _value ^ 0xFFFFFFFFu;
		}

		private static uint CalculateDigest(byte[] data, uint offset, uint size)
		{
			CRC cRC = new CRC();
			cRC.Update(data, offset, size);
			return cRC.GetDigest();
		}

		private static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
		{
			return CalculateDigest(data, offset, size) == digest;
		}
	}
	internal class DataErrorException : ApplicationException
	{
		public DataErrorException()
			: base("Data Error")
		{
		}
	}
	internal class InvalidParamException : ApplicationException
	{
		public InvalidParamException()
			: base("Invalid Parameter")
		{
		}
	}
	public interface ICodeProgress
	{
		void SetProgress(long inSize, long outSize);
	}
	public interface ICoder
	{
		void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress);
	}
	public enum CoderPropID
	{
		DefaultProp,
		DictionarySize,
		UsedMemorySize,
		Order,
		BlockSize,
		PosStateBits,
		LitContextBits,
		LitPosBits,
		NumFastBytes,
		MatchFinder,
		MatchFinderCycles,
		NumPasses,
		Algorithm,
		NumThreads,
		EndMarker
	}
	public interface ISetCoderProperties
	{
		void SetCoderProperties(CoderPropID[] propIDs, object[] properties);
	}
	public interface IWriteCoderProperties
	{
		void WriteCoderProperties(Stream outStream);
	}
	public interface ISetDecoderProperties
	{
		void SetDecoderProperties(byte[] properties);
	}
}
namespace SevenZip.Compression.RangeCoder
{
	internal class Encoder
	{
		public const uint kTopValue = 16777216u;

		private Stream Stream;

		public ulong Low;

		public uint Range;

		private uint _cacheSize;

		private byte _cache;

		private long StartPosition;

		public void SetStream(Stream stream)
		{
			Stream = stream;
		}

		public void ReleaseStream()
		{
			Stream = null;
		}

		public void Init()
		{
			StartPosition = Stream.Position;
			Low = 0uL;
			Range = uint.MaxValue;
			_cacheSize = 1u;
			_cache = 0;
		}

		public void FlushData()
		{
			for (int i = 0; i < 5; i++)
			{
				ShiftLow();
			}
		}

		public void FlushStream()
		{
			Stream.Flush();
		}

		public void CloseStream()
		{
			Stream.Close();
		}

		public void Encode(uint start, uint size, uint total)
		{
			Low += start * (Range /= total);
			Range *= size;
			while (Range < 16777216)
			{
				Range <<= 8;
				ShiftLow();
			}
		}

		public void ShiftLow()
		{
			if ((uint)Low < 4278190080u || (int)(Low >> 32) == 1)
			{
				byte b = _cache;
				do
				{
					Stream.WriteByte((byte)(b + (Low >> 32)));
					b = byte.MaxValue;
				}
				while (--_cacheSize != 0);
				_cache = (byte)((uint)Low >> 24);
			}
			_cacheSize++;
			Low = (uint)((int)Low << 8);
		}

		public void EncodeDirectBits(uint v, int numTotalBits)
		{
			for (int num = numTotalBits - 1; num >= 0; num--)
			{
				Range >>= 1;
				if (((v >> num) & 1) == 1)
				{
					Low += Range;
				}
				if (Range < 16777216)
				{
					Range <<= 8;
					ShiftLow();
				}
			}
		}

		public void EncodeBit(uint size0, int numTotalBits, uint symbol)
		{
			uint num = (Range >> numTotalBits) * size0;
			if (symbol == 0)
			{
				Range = num;
			}
			else
			{
				Low += num;
				Range -= num;
			}
			while (Range < 16777216)
			{
				Range <<= 8;
				ShiftLow();
			}
		}

		public long GetProcessedSizeAdd()
		{
			return _cacheSize + Stream.Position - StartPosition + 4;
		}
	}
	internal class Decoder
	{
		public const uint kTopValue = 16777216u;

		public uint Range;

		public uint Code;

		public Stream Stream;

		public void Init(Stream stream)
		{
			Stream = stream;
			Code = 0u;
			Range = uint.MaxValue;
			for (int i = 0; i < 5; i++)
			{
				Code = (Code << 8) | (byte)Stream.ReadByte();
			}
		}

		public void ReleaseStream()
		{
			Stream = null;
		}

		public void CloseStream()
		{
			Stream.Close();
		}

		public void Normalize()
		{
			while (Range < 16777216)
			{
				Code = (Code << 8) | (byte)Stream.ReadByte();
				Range <<= 8;
			}
		}

		public void Normalize2()
		{
			if (Range < 16777216)
			{
				Code = (Code << 8) | (byte)Stream.ReadByte();
				Range <<= 8;
			}
		}

		public uint GetThreshold(uint total)
		{
			return Code / (Range /= total);
		}

		public void Decode(uint start, uint size, uint total)
		{
			Code -= start * Range;
			Range *= size;
			Normalize();
		}

		public uint DecodeDirectBits(int numTotalBits)
		{
			uint num = Range;
			uint num2 = Code;
			uint num3 = 0u;
			for (int num4 = numTotalBits; num4 > 0; num4--)
			{
				num >>= 1;
				uint num5 = num2 - num >> 31;
				num2 -= num & (num5 - 1);
				num3 = (num3 << 1) | (1 - num5);
				if (num < 16777216)
				{
					num2 = (num2 << 8) | (byte)Stream.ReadByte();
					num <<= 8;
				}
			}
			Range = num;
			Code = num2;
			return num3;
		}

		public uint DecodeBit(uint size0, int numTotalBits)
		{
			uint num = (Range >> numTotalBits) * size0;
			uint result;
			if (Code < num)
			{
				result = 0u;
				Range = num;
			}
			else
			{
				result = 1u;
				Code -= num;
				Range -= num;
			}
			Normalize();
			return result;
		}
	}
	internal struct BitEncoder
	{
		public const int kNumBitModelTotalBits = 11;

		public const uint kBitModelTotal = 2048u;

		private const int kNumMoveBits = 5;

		private const int kNumMoveReducingBits = 2;

		public const int kNumBitPriceShiftBits = 6;

		private uint Prob;

		private static uint[] ProbPrices;

		public void Init()
		{
			Prob = 1024u;
		}

		public void UpdateModel(uint symbol)
		{
			if (symbol == 0)
			{
				Prob += 2048 - Prob >> 5;
			}
			else
			{
				Prob -= Prob >> 5;
			}
		}

		public void Encode(Encoder encoder, uint symbol)
		{
			uint num = (encoder.Range >> 11) * Prob;
			if (symbol == 0)
			{
				encoder.Range = num;
				Prob += 2048 - Prob >> 5;
			}
			else
			{
				encoder.Low += num;
				encoder.Range -= num;
				Prob -= Prob >> 5;
			}
			if (encoder.Range < 16777216)
			{
				encoder.Range <<= 8;
				encoder.ShiftLow();
			}
		}

		static BitEncoder()
		{
			ProbPrices = new uint[512];
			for (int num = 8; num >= 0; num--)
			{
				uint num2 = (uint)(1 << 9 - num - 1);
				uint num3 = (uint)(1 << 9 - num);
				for (uint num4 = num2; num4 < num3; num4++)
				{
					ProbPrices[num4] = (uint)(num << 6) + (num3 - num4 << 6 >> 9 - num - 1);
				}
			}
		}

		public uint GetPrice(uint symbol)
		{
			return ProbPrices[(((Prob - symbol) ^ (int)(0 - symbol)) & 0x7FF) >> 2];
		}

		public uint GetPrice0()
		{
			return ProbPrices[Prob >> 2];
		}

		public uint GetPrice1()
		{
			return ProbPrices[2048 - Prob >> 2];
		}
	}
	internal struct BitDecoder
	{
		public const int kNumBitModelTotalBits = 11;

		public const uint kBitModelTotal = 2048u;

		private const int kNumMoveBits = 5;

		private uint Prob;

		public void UpdateModel(int numMoveBits, uint symbol)
		{
			if (symbol == 0)
			{
				Prob += 2048 - Prob >> numMoveBits;
			}
			else
			{
				Prob -= Prob >> numMoveBits;
			}
		}

		public void Init()
		{
			Prob = 1024u;
		}

		public uint Decode(Decoder rangeDecoder)
		{
			uint num = (rangeDecoder.Range >> 11) * Prob;
			if (rangeDecoder.Code < num)
			{
				rangeDecoder.Range = num;
				Prob += 2048 - Prob >> 5;
				if (rangeDecoder.Range < 16777216)
				{
					rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
					rangeDecoder.Range <<= 8;
				}
				return 0u;
			}
			rangeDecoder.Range -= num;
			rangeDecoder.Code -= num;
			Prob -= Prob >> 5;
			if (rangeDecoder.Range < 16777216)
			{
				rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
				rangeDecoder.Range <<= 8;
			}
			return 1u;
		}
	}
	internal struct BitTreeEncoder
	{
		private BitEncoder[] Models;

		private int NumBitLevels;

		public BitTreeEncoder(int numBitLevels)
		{
			NumBitLevels = numBitLevels;
			Models = new BitEncoder[1 << numBitLevels];
		}

		public void Init()
		{
			for (uint num = 1u; num < 1 << NumBitLevels; num++)
			{
				Models[num].Init();
			}
		}

		public void Encode(Encoder rangeEncoder, uint symbol)
		{
			uint num = 1u;
			int num2 = NumBitLevels;
			while (num2 > 0)
			{
				num2--;
				uint num3 = (symbol >> num2) & 1u;
				Models[num].Encode(rangeEncoder, num3);
				num = (num << 1) | num3;
			}
		}

		public void ReverseEncode(Encoder rangeEncoder, uint symbol)
		{
			uint num = 1u;
			for (uint num2 = 0u; num2 < NumBitLevels; num2++)
			{
				uint num3 = symbol & 1u;
				Models[num].Encode(rangeEncoder, num3);
				num = (num << 1) | num3;
				symbol >>= 1;
			}
		}

		public uint GetPrice(uint symbol)
		{
			uint num = 0u;
			uint num2 = 1u;
			int num3 = NumBitLevels;
			while (num3 > 0)
			{
				num3--;
				uint num4 = (symbol >> num3) & 1u;
				num += Models[num2].GetPrice(num4);
				num2 = (num2 << 1) + num4;
			}
			return num;
		}

		public uint ReverseGetPrice(uint symbol)
		{
			uint num = 0u;
			uint num2 = 1u;
			for (int num3 = NumBitLevels; num3 > 0; num3--)
			{
				uint num4 = symbol & 1u;
				symbol >>= 1;
				num += Models[num2].GetPrice(num4);
				num2 = (num2 << 1) | num4;
			}
			return num;
		}

		public static uint ReverseGetPrice(BitEncoder[] Models, uint startIndex, int NumBitLevels, uint symbol)
		{
			uint num = 0u;
			uint num2 = 1u;
			for (int num3 = NumBitLevels; num3 > 0; num3--)
			{
				uint num4 = symbol & 1u;
				symbol >>= 1;
				num += Models[startIndex + num2].GetPrice(num4);
				num2 = (num2 << 1) | num4;
			}
			return num;
		}

		public static void ReverseEncode(BitEncoder[] Models, uint startIndex, Encoder rangeEncoder, int NumBitLevels, uint symbol)
		{
			uint num = 1u;
			for (int i = 0; i < NumBitLevels; i++)
			{
				uint num2 = symbol & 1u;
				Models[startIndex + num].Encode(rangeEncoder, num2);
				num = (num << 1) | num2;
				symbol >>= 1;
			}
		}
	}
	internal struct BitTreeDecoder
	{
		private BitDecoder[] Models;

		private int NumBitLevels;

		public BitTreeDecoder(int numBitLevels)
		{
			NumBitLevels = numBitLevels;
			Models = new BitDecoder[1 << numBitLevels];
		}

		public void Init()
		{
			for (uint num = 1u; num < 1 << NumBitLevels; num++)
			{
				Models[num].Init();
			}
		}

		public uint Decode(Decoder rangeDecoder)
		{
			uint num = 1u;
			for (int num2 = NumBitLevels; num2 > 0; num2--)
			{
				num = (num << 1) + Models[num].Decode(rangeDecoder);
			}
			return num - (uint)(1 << NumBitLevels);
		}

		public uint ReverseDecode(Decoder rangeDecoder)
		{
			uint num = 1u;
			uint num2 = 0u;
			for (int i = 0; i < NumBitLevels; i++)
			{
				uint num3 = Models[num].Decode(rangeDecoder);
				num <<= 1;
				num += num3;
				num2 |= num3 << i;
			}
			return num2;
		}

		public static uint ReverseDecode(BitDecoder[] Models, uint startIndex, Decoder rangeDecoder, int NumBitLevels)
		{
			uint num = 1u;
			uint num2 = 0u;
			for (int i = 0; i < NumBitLevels; i++)
			{
				uint num3 = Models[startIndex + num].Decode(rangeDecoder);
				num <<= 1;
				num += num3;
				num2 |= num3 << i;
			}
			return num2;
		}
	}
}
namespace SevenZip.Compression.LZ
{
	internal interface IInWindowStream
	{
		void SetStream(Stream inStream);

		void Init();

		void ReleaseStream();

		byte GetIndexByte(int index);

		uint GetMatchLen(int index, uint distance, uint limit);

		uint GetNumAvailableBytes();
	}
	internal interface IMatchFinder : IInWindowStream
	{
		void Create(uint historySize, uint keepAddBufferBefore, uint matchMaxLen, uint keepAddBufferAfter);

		uint GetMatches(uint[] distances);

		void Skip(uint num);
	}
	public class BinTree : InWindow, IMatchFinder, IInWindowStream
	{
		private uint _cyclicBufferPos;

		private uint _cyclicBufferSize = 0u;

		private uint _matchMaxLen;

		private uint[] _son;

		private uint[] _hash;

		private uint _cutValue = 255u;

		private uint _hashMask;

		private uint _hashSizeSum = 0u;

		private bool HASH_ARRAY = true;

		private const uint kHash2Size = 1024u;

		private const uint kHash3Size = 65536u;

		private const uint kBT2HashSize = 65536u;

		private const uint kStartMaxLen = 1u;

		private const uint kHash3Offset = 1024u;

		private const uint kEmptyHashValue = 0u;

		private const uint kMaxValForNormalize = 2147483647u;

		private uint kNumHashDirectBytes = 0u;

		private uint kMinMatchCheck = 4u;

		private uint kFixHashSize = 66560u;

		public void SetType(int numHashBytes)
		{
			HASH_ARRAY = numHashBytes > 2;
			if (HASH_ARRAY)
			{
				kNumHashDirectBytes = 0u;
				kMinMatchCheck = 4u;
				kFixHashSize = 66560u;
			}
			else
			{
				kNumHashDirectBytes = 2u;
				kMinMatchCheck = 3u;
				kFixHashSize = 0u;
			}
		}

		public new void SetStream(Stream stream)
		{
			base.SetStream(stream);
		}

		public new void ReleaseStream()
		{
			base.ReleaseStream();
		}

		public new void Init()
		{
			base.Init();
			for (uint num = 0u; num < _hashSizeSum; num++)
			{
				_hash[num] = 0u;
			}
			_cyclicBufferPos = 0u;
			ReduceOffsets(-1);
		}

		public new void MovePos()
		{
			if (++_cyclicBufferPos >= _cyclicBufferSize)
			{
				_cyclicBufferPos = 0u;
			}
			base.MovePos();
			if (_pos == int.MaxValue)
			{
				Normalize();
			}
		}

		public new byte GetIndexByte(int index)
		{
			return base.GetIndexByte(index);
		}

		public new uint GetMatchLen(int index, uint distance, uint limit)
		{
			return base.GetMatchLen(index, distance, limit);
		}

		public new uint GetNumAvailableBytes()
		{
			return base.GetNumAvailableBytes();
		}

		public void Create(uint historySize, uint keepAddBufferBefore, uint matchMaxLen, uint keepAddBufferAfter)
		{
			if (historySize > 2147483391)
			{
				throw new Exception();
			}
			_cutValue = 16 + (matchMaxLen >> 1);
			uint keepSizeReserv = (historySize + keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + 256;
			Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, keepSizeReserv);
			_matchMaxLen = matchMaxLen;
			uint num = historySize + 1;
			if (_cyclicBufferSize != num)
			{
				_son = new uint[(_cyclicBufferSize = num) * 2];
			}
			uint num2 = 65536u;
			if (HASH_ARRAY)
			{
				num2 = historySize - 1;
				num2 |= num2 >> 1;
				num2 |= num2 >> 2;
				num2 |= num2 >> 4;
				num2 |= num2 >> 8;
				num2 >>= 1;
				num2 |= 0xFFFFu;
				if (num2 > 16777216)
				{
					num2 >>= 1;
				}
				_hashMask = num2;
				num2++;
				num2 += kFixHashSize;
			}
			if (num2 != _hashSizeSum)
			{
				_hash = new uint[_hashSizeSum = num2];
			}
		}

		public uint GetMatches(uint[] distances)
		{
			uint num;
			if (_pos + _matchMaxLen <= _streamPos)
			{
				num = _matchMaxLen;
			}
			else
			{
				num = _streamPos - _pos;
				if (num < kMinMatchCheck)
				{
					MovePos();
					return 0u;
				}
			}
			uint num2 = 0u;
			uint num3 = ((_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0u);
			uint num4 = _bufferOffset + _pos;
			uint num5 = 1u;
			uint num6 = 0u;
			uint num7 = 0u;
			uint num9;
			if (HASH_ARRAY)
			{
				uint num8 = CRC.Table[_bufferBase[num4]] ^ _bufferBase[num4 + 1];
				num6 = num8 & 0x3FFu;
				num8 ^= (uint)(_bufferBase[num4 + 2] << 8);
				num7 = num8 & 0xFFFFu;
				num9 = (num8 ^ (CRC.Table[_bufferBase[num4 + 3]] << 5)) & _hashMask;
			}
			else
			{
				num9 = (uint)(_bufferBase[num4] ^ (_bufferBase[num4 + 1] << 8));
			}
			uint num10 = _hash[kFixHashSize + num9];
			if (HASH_ARRAY)
			{
				uint num11 = _hash[num6];
				uint num12 = _hash[1024 + num7];
				_hash[num6] = _pos;
				_hash[1024 + num7] = _pos;
				if (num11 > num3 && _bufferBase[_bufferOffset + num11] == _bufferBase[num4])
				{
					num5 = (distances[num2++] = 2u);
					distances[num2++] = _pos - num11 - 1;
				}
				if (num12 > num3 && _bufferBase[_bufferOffset + num12] == _bufferBase[num4])
				{
					if (num12 == num11)
					{
						num2 -= 2;
					}
					num5 = (distances[num2++] = 3u);
					distances[num2++] = _pos - num12 - 1;
					num11 = num12;
				}
				if (num2 != 0 && num11 == num10)
				{
					num2 -= 2;
					num5 = 1u;
				}
			}
			_hash[kFixHashSize + num9] = _pos;
			uint num13 = (_cyclicBufferPos << 1) + 1;
			uint num14 = _cyclicBufferPos << 1;
			uint val;
			uint val2 = (val = kNumHashDirectBytes);
			if (kNumHashDirectBytes != 0 && num10 > num3 && _bufferBase[_bufferOffset + num10 + kNumHashDirectBytes] != _bufferBase[num4 + kNumHashDirectBytes])
			{
				num5 = (distances[num2++] = kNumHashDirectBytes);
				distances[num2++] = _pos - num10 - 1;
			}
			uint cutValue = _cutValue;
			while (true)
			{
				if (num10 <= num3 || cutValue-- == 0)
				{
					_son[num13] = (_son[num14] = 0u);
					break;
				}
				uint num15 = _pos - num10;
				uint num16 = ((num15 <= _cyclicBufferPos) ? (_cyclicBufferPos - num15) : (_cyclicBufferPos - num15 + _cyclicBufferSize)) << 1;
				uint num17 = _bufferOffset + num10;
				uint num18 = Math.Min(val2, val);
				if (_bufferBase[num17 + num18] == _bufferBase[num4 + num18])
				{
					while (++num18 != num && _bufferBase[num17 + num18] == _bufferBase[num4 + num18])
					{
					}
					if (num5 < num18)
					{
						num5 = (distances[num2++] = num18);
						distances[num2++] = num15 - 1;
						if (num18 == num)
						{
							_son[num14] = _son[num16];
							_son[num13] = _son[num16 + 1];
							break;
						}
					}
				}
				if (_bufferBase[num17 + num18] < _bufferBase[num4 + num18])
				{
					_son[num14] = num10;
					num14 = num16 + 1;
					num10 = _son[num14];
					val = num18;
				}
				else
				{
					_son[num13] = num10;
					num13 = num16;
					num10 = _son[num13];
					val2 = num18;
				}
			}
			MovePos();
			return num2;
		}

		public void Skip(uint num)
		{
			do
			{
				uint num2;
				if (_pos + _matchMaxLen <= _streamPos)
				{
					num2 = _matchMaxLen;
				}
				else
				{
					num2 = _streamPos - _pos;
					if (num2 < kMinMatchCheck)
					{
						MovePos();
						continue;
					}
				}
				uint num3 = ((_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0u);
				uint num4 = _bufferOffset + _pos;
				uint num8;
				if (HASH_ARRAY)
				{
					uint num5 = CRC.Table[_bufferBase[num4]] ^ _bufferBase[num4 + 1];
					uint num6 = num5 & 0x3FFu;
					_hash[num6] = _pos;
					num5 ^= (uint)(_bufferBase[num4 + 2] << 8);
					uint num7 = num5 & 0xFFFFu;
					_hash[1024 + num7] = _pos;
					num8 = (num5 ^ (CRC.Table[_bufferBase[num4 + 3]] << 5)) & _hashMask;
				}
				else
				{
					num8 = (uint)(_bufferBase[num4] ^ (_bufferBase[num4 + 1] << 8));
				}
				uint num9 = _hash[kFixHashSize + num8];
				_hash[kFixHashSize + num8] = _pos;
				uint num10 = (_cyclicBufferPos << 1) + 1;
				uint num11 = _cyclicBufferPos << 1;
				uint val;
				uint val2 = (val = kNumHashDirectBytes);
				uint cutValue = _cutValue;
				while (true)
				{
					if (num9 <= num3 || cutValue-- == 0)
					{
						_son[num10] = (_son[num11] = 0u);
						break;
					}
					uint num12 = _pos - num9;
					uint num13 = ((num12 <= _cyclicBufferPos) ? (_cyclicBufferPos - num12) : (_cyclicBufferPos - num12 + _cyclicBufferSize)) << 1;
					uint num14 = _bufferOffset + num9;
					uint num15 = Math.Min(val2, val);
					if (_bufferBase[num14 + num15] == _bufferBase[num4 + num15])
					{
						while (++num15 != num2 && _bufferBase[num14 + num15] == _bufferBase[num4 + num15])
						{
						}
						if (num15 == num2)
						{
							_son[num11] = _son[num13];
							_son[num10] = _son[num13 + 1];
							break;
						}
					}
					if (_bufferBase[num14 + num15] < _bufferBase[num4 + num15])
					{
						_son[num11] = num9;
						num11 = num13 + 1;
						num9 = _son[num11];
						val = num15;
					}
					else
					{
						_son[num10] = num9;
						num10 = num13;
						num9 = _son[num10];
						val2 = num15;
					}
				}
				MovePos();
			}
			while (--num != 0);
		}

		private void NormalizeLinks(uint[] items, uint numItems, uint subValue)
		{
			for (uint num = 0u; num < numItems; num++)
			{
				uint num2 = items[num];
				num2 = ((num2 > subValue) ? (num2 - subValue) : 0u);
				items[num] = num2;
			}
		}

		private void Normalize()
		{
			uint subValue = _pos - _cyclicBufferSize;
			NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
			NormalizeLinks(_hash, _hashSizeSum, subValue);
			ReduceOffsets((int)subValue);
		}

		public void SetCutValue(uint cutValue)
		{
			_cutValue = cutValue;
		}
	}
	public class InWindow
	{
		public byte[] _bufferBase = null;

		private Stream _stream;

		private uint _posLimit;

		private bool _streamEndWasReached;

		private uint _pointerToLastSafePosition;

		public uint _bufferOffset;

		public uint _blockSize;

		public uint _pos;

		private uint _keepSizeBefore;

		private uint _keepSizeAfter;

		public uint _streamPos;

		public void MoveBlock()
		{
			uint num = _bufferOffset + _pos - _keepSizeBefore;
			if (num != 0)
			{
				num--;
			}
			uint num2 = _bufferOffset + _streamPos - num;
			for (uint num3 = 0u; num3 < num2; num3++)
			{
				_bufferBase[num3] = _bufferBase[num + num3];
			}
			_bufferOffset -= num;
		}

		public virtual void ReadBlock()
		{
			if (_streamEndWasReached)
			{
				return;
			}
			while (true)
			{
				int num = (int)(0 - _bufferOffset + _blockSize - _streamPos);
				if (num == 0)
				{
					return;
				}
				int num2 = _stream.Read(_bufferBase, (int)(_bufferOffset + _streamPos), num);
				if (num2 == 0)
				{
					break;
				}
				_streamPos += (uint)num2;
				if (_streamPos >= _pos + _keepSizeAfter)
				{
					_posLimit = _streamPos - _keepSizeAfter;
				}
			}
			_posLimit = _streamPos;
			uint num3 = _bufferOffset + _posLimit;
			if (num3 > _pointerToLastSafePosition)
			{
				_posLimit = _pointerToLastSafePosition - _bufferOffset;
			}
			_streamEndWasReached = true;
		}

		private void Free()
		{
			_bufferBase = null;
		}

		public void Create(uint keepSizeBefore, uint keepSizeAfter, uint keepSizeReserv)
		{
			_keepSizeBefore = keepSizeBefore;
			_keepSizeAfter = keepSizeAfter;
			uint num = keepSizeBefore + keepSizeAfter + keepSizeReserv;
			if (_bufferBase == null || _blockSize != num)
			{
				Free();
				_blockSize = num;
				_bufferBase = new byte[_blockSize];
			}
			_pointerToLastSafePosition = _blockSize - keepSizeAfter;
		}

		public void SetStream(Stream stream)
		{
			_stream = stream;
		}

		public void ReleaseStream()
		{
			_stream = null;
		}

		public void Init()
		{
			_bufferOffset = 0u;
			_pos = 0u;
			_streamPos = 0u;
			_streamEndWasReached = false;
			ReadBlock();
		}

		public void MovePos()
		{
			_pos++;
			if (_pos > _posLimit)
			{
				uint num = _bufferOffset + _pos;
				if (num > _pointerToLastSafePosition)
				{
					MoveBlock();
				}
				ReadBlock();
			}
		}

		public byte GetIndexByte(int index)
		{
			return _bufferBase[_bufferOffset + _pos + index];
		}

		public uint GetMatchLen(int index, uint distance, uint limit)
		{
			if (_streamEndWasReached && _pos + index + limit > _streamPos)
			{
				limit = _streamPos - (uint)(int)(_pos + index);
			}
			distance++;
			uint num = _bufferOffset + _pos + (uint)index;
			uint num2;
			for (num2 = 0u; num2 < limit && _bufferBase[num + num2] == _bufferBase[num + num2 - distance]; num2++)
			{
			}
			return num2;
		}

		public uint GetNumAvailableBytes()
		{
			return _streamPos - _pos;
		}

		public void ReduceOffsets(int subValue)
		{
			_bufferOffset += (uint)subValue;
			_posLimit -= (uint)subValue;
			_pos -= (uint)subValue;
			_streamPos -= (uint)subValue;
		}
	}
	public class OutWindow
	{
		private byte[] _buffer = null;

		private uint _pos;

		private uint _windowSize = 0u;

		private uint _streamPos;

		private Stream _stream;

		public uint TrainSize = 0u;

		public void Create(uint windowSize)
		{
			if (_windowSize != windowSize)
			{
				_buffer = new byte[windowSize];
			}
			_windowSize = windowSize;
			_pos = 0u;
			_streamPos = 0u;
		}

		public void Init(Stream stream, bool solid)
		{
			ReleaseStream();
			_stream = stream;
			if (!solid)
			{
				_streamPos = 0u;
				_pos = 0u;
				TrainSize = 0u;
			}
		}

		public bool Train(Stream stream)
		{
			long length = stream.Length;
			uint num = (TrainSize = (uint)((length < _windowSize) ? length : _windowSize));
			stream.Position = length - num;
			_streamPos = (_pos = 0u);
			while (num != 0)
			{
				uint num2 = _windowSize - _pos;
				if (num < num2)
				{
					num2 = num;
				}
				int num3 = stream.Read(_buffer, (int)_pos, (int)num2);
				if (num3 == 0)
				{
					return false;
				}
				num -= (uint)num3;
				_pos += (uint)num3;
				_streamPos += (uint)num3;
				if (_pos == _windowSize)
				{
					_streamPos = (_pos = 0u);
				}
			}
			return true;
		}

		public void ReleaseStream()
		{
			Flush();
			_stream = null;
		}

		public void Flush()
		{
			uint num = _pos - _streamPos;
			if (num != 0)
			{
				_stream.Write(_buffer, (int)_streamPos, (int)num);
				if (_pos >= _windowSize)
				{
					_pos = 0u;
				}
				_streamPos = _pos;
			}
		}

		public void CopyBlock(uint distance, uint len)
		{
			uint num = _pos - distance - 1;
			if (num >= _windowSize)
			{
				num += _windowSize;
			}
			while (len != 0)
			{
				if (num >= _windowSize)
				{
					num = 0u;
				}
				_buffer[_pos++] = _buffer[num++];
				if (_pos >= _windowSize)
				{
					Flush();
				}
				len--;
			}
		}

		public void PutByte(byte b)
		{
			_buffer[_pos++] = b;
			if (_pos >= _windowSize)
			{
				Flush();
			}
		}

		public byte GetByte(uint distance)
		{
			uint num = _pos - distance - 1;
			if (num >= _windowSize)
			{
				num += _windowSize;
			}
			return _buffer[num];
		}
	}
}
namespace SevenZip.Compression.LZMA
{
	internal abstract class Base
	{
		public struct State
		{
			public uint Index;

			public void Init()
			{
				Index = 0u;
			}

			public void UpdateChar()
			{
				if (Index < 4)
				{
					Index = 0u;
				}
				else if (Index < 10)
				{
					Index -= 3u;
				}
				else
				{
					Index -= 6u;
				}
			}

			public void UpdateMatch()
			{
				Index = ((Index < 7) ? 7u : 10u);
			}

			public void UpdateRep()
			{
				Index = ((Index < 7) ? 8u : 11u);
			}

			public void UpdateShortRep()
			{
				Index = ((Index < 7) ? 9u : 11u);
			}

			public bool IsCharState()
			{
				return Index < 7;
			}
		}

		public const uint kNumRepDistances = 4u;

		public const uint kNumStates = 12u;

		public const int kNumPosSlotBits = 6;

		public const int kDicLogSizeMin = 0;

		public const int kNumLenToPosStatesBits = 2;

		public const uint kNumLenToPosStates = 4u;

		public const uint kMatchMinLen = 2u;

		public const int kNumAlignBits = 4;

		public const uint kAlignTableSize = 16u;

		public const uint kAlignMask = 15u;

		public const uint kStartPosModelIndex = 4u;

		public const uint kEndPosModelIndex = 14u;

		public const uint kNumPosModels = 10u;

		public const uint kNumFullDistances = 128u;

		public const uint kNumLitPosStatesBitsEncodingMax = 4u;

		public const uint kNumLitContextBitsMax = 8u;

		public const int kNumPosStatesBitsMax = 4;

		public const uint kNumPosStatesMax = 16u;

		public const int kNumPosStatesBitsEncodingMax = 4;

		public const uint kNumPosStatesEncodingMax = 16u;

		public const int kNumLowLenBits = 3;

		public const int kNumMidLenBits = 3;

		public const int kNumHighLenBits = 8;

		public const uint kNumLowLenSymbols = 8u;

		public const uint kNumMidLenSymbols = 8u;

		public const uint kNumLenSymbols = 272u;

		public const uint kMatchMaxLen = 273u;

		public static uint GetLenToPosState(uint len)
		{
			len -= 2;
			if (len < 4)
			{
				return len;
			}
			return 3u;
		}
	}
	public class Decoder : ICoder, ISetDecoderProperties
	{
		private class LenDecoder
		{
			private BitDecoder m_Choice = default(BitDecoder);

			private BitDecoder m_Choice2 = default(BitDecoder);

			private BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[16];

			private BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[16];

			private BitTreeDecoder m_HighCoder = new BitTreeDecoder(8);

			private uint m_NumPosStates = 0u;

			public void Create(uint numPosStates)
			{
				for (uint num = m_NumPosStates; num < numPosStates; num++)
				{
					m_LowCoder[num] = new BitTreeDecoder(3);
					m_MidCoder[num] = new BitTreeDecoder(3);
				}
				m_NumPosStates = numPosStates;
			}

			public void Init()
			{
				m_Choice.Init();
				for (uint num = 0u; num < m_NumPosStates; num++)
				{
					m_LowCoder[num].Init();
					m_MidCoder[num].Init();
				}
				m_Choice2.Init();
				m_HighCoder.Init();
			}

			public uint Decode(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, uint posState)
			{
				if (m_Choice.Decode(rangeDecoder) == 0)
				{
					return m_LowCoder[posState].Decode(rangeDecoder);
				}
				uint num = 8u;
				if (m_Choice2.Decode(rangeDecoder) == 0)
				{
					num += m_MidCoder[posState].Decode(rangeDecoder);
				}
				else
				{
					num += 8;
					num += m_HighCoder.Decode(rangeDecoder);
				}
				return num;
			}
		}

		private class LiteralDecoder
		{
			private struct Decoder2
			{
				private BitDecoder[] m_Decoders;

				public void Create()
				{
					m_Decoders = new BitDecoder[768];
				}

				public void Init()
				{
					for (int i = 0; i < 768; i++)
					{
						m_Decoders[i].Init();
					}
				}

				public byte DecodeNormal(SevenZip.Compression.RangeCoder.Decoder rangeDecoder)
				{
					uint num = 1u;
					do
					{
						num = (num << 1) | m_Decoders[num].Decode(rangeDecoder);
					}
					while (num < 256);
					return (byte)num;
				}

				public byte DecodeWithMatchByte(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, byte matchByte)
				{
					uint num = 1u;
					do
					{
						uint num2 = (uint)(matchByte >> 7) & 1u;
						matchByte <<= 1;
						uint num3 = m_Decoders[(1 + num2 << 8) + num].Decode(rangeDecoder);
						num = (num << 1) | num3;
						if (num2 != num3)
						{
							while (num < 256)
							{
								num = (num << 1) | m_Decoders[num].Decode(rangeDecoder);
							}
							break;
						}
					}
					while (num < 256);
					return (byte)num;
				}
			}

			private Decoder2[] m_Coders;

			private int m_NumPrevBits;

			private int m_NumPosBits;

			private uint m_PosMask;

			public void Create(int numPosBits, int numPrevBits)
			{
				if (m_Coders == null || m_NumPrevBits != numPrevBits || m_NumPosBits != numPosBits)
				{
					m_NumPosBits = numPosBits;
					m_PosMask = (uint)((1 << numPosBits) - 1);
					m_NumPrevBits = numPrevBits;
					uint num = (uint)(1 << m_NumPrevBits + m_NumPosBits);
					m_Coders = new Decoder2[num];
					for (uint num2 = 0u; num2 < num; num2++)
					{
						m_Coders[num2].Create();
					}
				}
			}

			public void Init()
			{
				uint num = (uint)(1 << m_NumPrevBits + m_NumPosBits);
				for (uint num2 = 0u; num2 < num; num2++)
				{
					m_Coders[num2].Init();
				}
			}

			private uint GetState(uint pos, byte prevByte)
			{
				return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> 8 - m_NumPrevBits);
			}

			public byte DecodeNormal(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
			{
				return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder);
			}

			public byte DecodeWithMatchByte(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
			{
				return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte);
			}
		}

		private OutWindow m_OutWindow = new OutWindow();

		private SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder = new SevenZip.Compression.RangeCoder.Decoder();

		private BitDecoder[] m_IsMatchDecoders = new BitDecoder[192];

		private BitDecoder[] m_IsRepDecoders = new BitDecoder[12];

		private BitDecoder[] m_IsRepG0Decoders = new BitDecoder[12];

		private BitDecoder[] m_IsRepG1Decoders = new BitDecoder[12];

		private BitDecoder[] m_IsRepG2Decoders = new BitDecoder[12];

		private BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[192];

		private BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[4];

		private BitDecoder[] m_PosDecoders = new BitDecoder[114];

		private BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(4);

		private LenDecoder m_LenDecoder = new LenDecoder();

		private LenDecoder m_RepLenDecoder = new LenDecoder();

		private LiteralDecoder m_LiteralDecoder = new LiteralDecoder();

		private uint m_DictionarySize;

		private uint m_DictionarySizeCheck;

		private uint m_PosStateMask;

		private bool _solid = false;

		public Decoder()
		{
			m_DictionarySize = uint.MaxValue;
			for (int i = 0; (long)i < 4L; i++)
			{
				m_PosSlotDecoder[i] = new BitTreeDecoder(6);
			}
		}

		private void SetDictionarySize(uint dictionarySize)
		{
			if (m_DictionarySize != dictionarySize)
			{
				m_DictionarySize = dictionarySize;
				m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1u);
				uint windowSize = Math.Max(m_DictionarySizeCheck, 4096u);
				m_OutWindow.Create(windowSize);
			}
		}

		private void SetLiteralProperties(int lp, int lc)
		{
			if (lp > 8)
			{
				throw new InvalidParamException();
			}
			if (lc > 8)
			{
				throw new InvalidParamException();
			}
			m_LiteralDecoder.Create(lp, lc);
		}

		private void SetPosBitsProperties(int pb)
		{
			if (pb > 4)
			{
				throw new InvalidParamException();
			}
			uint num = (uint)(1 << pb);
			m_LenDecoder.Create(num);
			m_RepLenDecoder.Create(num);
			m_PosStateMask = num - 1;
		}

		private void Init(Stream inStream, Stream outStream)
		{
			m_RangeDecoder.Init(inStream);
			m_OutWindow.Init(outStream, _solid);
			for (uint num = 0u; num < 12; num++)
			{
				for (uint num2 = 0u; num2 <= m_PosStateMask; num2++)
				{
					uint num3 = (num << 4) + num2;
					m_IsMatchDecoders[num3].Init();
					m_IsRep0LongDecoders[num3].Init();
				}
				m_IsRepDecoders[num].Init();
				m_IsRepG0Decoders[num].Init();
				m_IsRepG1Decoders[num].Init();
				m_IsRepG2Decoders[num].Init();
			}
			m_LiteralDecoder.Init();
			for (uint num = 0u; num < 4; num++)
			{
				m_PosSlotDecoder[num].Init();
			}
			for (uint num = 0u; num < 114; num++)
			{
				m_PosDecoders[num].Init();
			}
			m_LenDecoder.Init();
			m_RepLenDecoder.Init();
			m_PosAlignDecoder.Init();
		}

		public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
		{
			Init(inStream, outStream);
			Base.State state = default(Base.State);
			state.Init();
			uint num = 0u;
			uint num2 = 0u;
			uint num3 = 0u;
			uint num4 = 0u;
			ulong num5 = 0uL;
			if (num5 < (ulong)outSize)
			{
				if (m_IsMatchDecoders[state.Index << 4].Decode(m_RangeDecoder) != 0)
				{
					throw new DataErrorException();
				}
				state.UpdateChar();
				byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0u, 0);
				m_OutWindow.PutByte(b);
				num5++;
			}
			while (num5 < (ulong)outSize)
			{
				uint num6 = (uint)(int)num5 & m_PosStateMask;
				if (m_IsMatchDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
				{
					byte @byte = m_OutWindow.GetByte(0u);
					byte b2 = (state.IsCharState() ? m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)num5, @byte) : m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder, (uint)num5, @byte, m_OutWindow.GetByte(num)));
					m_OutWindow.PutByte(b2);
					state.UpdateChar();
					num5++;
					continue;
				}
				uint num8;
				if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
				{
					if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
					{
						if (m_IsRep0LongDecoders[(state.Index << 4) + num6].Decode(m_RangeDecoder) == 0)
						{
							state.UpdateShortRep();
							m_OutWindow.PutByte(m_OutWindow.GetByte(num));
							num5++;
							continue;
						}
					}
					else
					{
						uint num7;
						if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
						{
							num7 = num2;
						}
						else
						{
							if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
							{
								num7 = num3;
							}
							else
							{
								num7 = num4;
								num4 = num3;
							}
							num3 = num2;
						}
						num2 = num;
						num = num7;
					}
					num8 = m_RepLenDecoder.Decode(m_RangeDecoder, num6) + 2;
					state.UpdateRep();
				}
				else
				{
					num4 = num3;
					num3 = num2;
					num2 = num;
					num8 = 2 + m_LenDecoder.Decode(m_RangeDecoder, num6);
					state.UpdateMatch();
					uint num9 = m_PosSlotDecoder[Base.GetLenToPosState(num8)].Decode(m_RangeDecoder);
					if (num9 >= 4)
					{
						int num10 = (int)((num9 >> 1) - 1);
						num = (2 | (num9 & 1)) << num10;
						if (num9 < 14)
						{
							num += BitTreeDecoder.ReverseDecode(m_PosDecoders, num - num9 - 1, m_RangeDecoder, num10);
						}
						else
						{
							num += m_RangeDecoder.DecodeDirectBits(num10 - 4) << 4;
							num += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
						}
					}
					else
					{
						num = num9;
					}
				}
				if (num >= m_OutWindow.TrainSize + num5 || num >= m_DictionarySizeCheck)
				{
					if (num == uint.MaxValue)
					{
						break;
					}
					throw new DataErrorException();
				}
				m_OutWindow.CopyBlock(num, num8);
				num5 += num8;
			}
			m_OutWindow.Flush();
			m_OutWindow.ReleaseStream();
			m_RangeDecoder.ReleaseStream();
		}

		public void SetDecoderProperties(byte[] properties)
		{
			if (properties.Length < 5)
			{
				throw new InvalidParamException();
			}
			int lc = properties[0] % 9;
			int num = properties[0] / 9;
			int lp = num % 5;
			int num2 = num / 5;
			if (num2 > 4)
			{
				throw new InvalidParamException();
			}
			uint num3 = 0u;
			for (int i = 0; i < 4; i++)
			{
				num3 += (uint)(properties[1 + i] << i * 8);
			}
			SetDictionarySize(num3);
			SetLiteralProperties(lp, lc);
			SetPosBitsProperties(num2);
		}

		public bool Train(Stream stream)
		{
			_solid = true;
			return m_OutWindow.Train(stream);
		}
	}
	public class Encoder : ICoder, ISetCoderProperties, IWriteCoderProperties
	{
		private enum EMatchFinderType
		{
			BT2,
			BT4
		}

		private class LiteralEncoder
		{
			public struct Encoder2
			{
				private BitEncoder[] m_Encoders;

				public void Create()
				{
					m_Encoders = new BitEncoder[768];
				}

				public void Init()
				{
					for (int i = 0; i < 768; i++)
					{
						m_Encoders[i].Init();
					}
				}

				public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte symbol)
				{
					uint num = 1u;
					for (int num2 = 7; num2 >= 0; num2--)
					{
						uint num3 = (uint)(symbol >> num2) & 1u;
						m_Encoders[num].Encode(rangeEncoder, num3);
						num = (num << 1) | num3;
					}
				}

				public void EncodeMatched(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol)
				{
					uint num = 1u;
					bool flag = true;
					for (int num2 = 7; num2 >= 0; num2--)
					{
						uint num3 = (uint)(symbol >> num2) & 1u;
						uint num4 = num;
						if (flag)
						{
							uint num5 = (uint)(matchByte >> num2) & 1u;
							num4 += 1 + num5 << 8;
							flag = num5 == num3;
						}
						m_Encoders[num4].Encode(rangeEncoder, num3);
						num = (num << 1) | num3;
					}
				}

				public uint GetPrice(bool matchMode, byte matchByte, byte symbol)
				{
					uint num = 0u;
					uint num2 = 1u;
					int num3 = 7;
					if (matchMode)
					{
						while (num3 >= 0)
						{
							uint num4 = (uint)(matchByte >> num3) & 1u;
							uint num5 = (uint)(symbol >> num3) & 1u;
							num += m_Encoders[(1 + num4 << 8) + num2].GetPrice(num5);
							num2 = (num2 << 1) | num5;
							if (num4 != num5)
							{
								num3--;
								break;
							}
							num3--;
						}
					}
					while (num3 >= 0)
					{
						uint num6 = (uint)(symbol >> num3) & 1u;
						num += m_Encoders[num2].GetPrice(num6);
						num2 = (num2 << 1) | num6;
						num3--;
					}
					return num;
				}
			}

			private Encoder2[] m_Coders;

			private int m_NumPrevBits;

			private int m_NumPosBits;

			private uint m_PosMask;

			public void Create(int numPosBits, int numPrevBits)
			{
				if (m_Coders == null || m_NumPrevBits != numPrevBits || m_NumPosBits != numPosBits)
				{
					m_NumPosBits = numPosBits;
					m_PosMask = (uint)((1 << numPosBits) - 1);
					m_NumPrevBits = numPrevBits;
					uint num = (uint)(1 << m_NumPrevBits + m_NumPosBits);
					m_Coders = new Encoder2[num];
					for (uint num2 = 0u; num2 < num; num2++)
					{
						m_Coders[num2].Create();
					}
				}
			}

			public void Init()
			{
				uint num = (uint)(1 << m_NumPrevBits + m_NumPosBits);
				for (uint num2 = 0u; num2 < num; num2++)
				{
					m_Coders[num2].Init();
				}
			}

			public Encoder2 GetSubCoder(uint pos, byte prevByte)
			{
				return m_Coders[(int)((pos & m_PosMask) << m_NumPrevBits) + (prevByte >> 8 - m_NumPrevBits)];
			}
		}

		private class LenEncoder
		{
			private BitEncoder _choice = default(BitEncoder);

			private BitEncoder _choice2 = default(BitEncoder);

			private BitTreeEncoder[] _lowCoder = new BitTreeEncoder[16];

			private BitTreeEncoder[] _midCoder = new BitTreeEncoder[16];

			private BitTreeEncoder _highCoder = new BitTreeEncoder(8);

			public LenEncoder()
			{
				for (uint num = 0u; num < 16; num++)
				{
					_lowCoder[num] = new BitTreeEncoder(3);
					_midCoder[num] = new BitTreeEncoder(3);
				}
			}

			public void Init(uint numPosStates)
			{
				_choice.Init();
				_choice2.Init();
				for (uint num = 0u; num < numPosStates; num++)
				{
					_lowCoder[num].Init();
					_midCoder[num].Init();
				}
				_highCoder.Init();
			}

			public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, uint symbol, uint posState)
			{
				if (symbol < 8)
				{
					_choice.Encode(rangeEncoder, 0u);
					_lowCoder[posState].Encode(rangeEncoder, symbol);
					return;
				}
				symbol -= 8;
				_choice.Encode(rangeEncoder, 1u);
				if (symbol < 8)
				{
					_choice2.Encode(rangeEncoder, 0u);
					_midCoder[posState].Encode(rangeEncoder, symbol);
				}
				else
				{
					_choice2.Encode(rangeEncoder, 1u);
					_highCoder.Encode(rangeEncoder, symbol - 8);
				}
			}

			public void SetPrices(uint posState, uint numSymbols, uint[] prices, uint st)
			{
				uint price = _choice.GetPrice0();
				uint price2 = _choice.GetPrice1();
				uint num = price2 + _choice2.GetPrice0();
				uint num2 = price2 + _choice2.GetPrice1();
				uint num3 = 0u;
				for (num3 = 0u; num3 < 8; num3++)
				{
					if (num3 >= numSymbols)
					{
						return;
					}
					prices[st + num3] = price + _lowCoder[posState].GetPrice(num3);
				}
				for (; num3 < 16; num3++)
				{
					if (num3 >= numSymbols)
					{
						return;
					}
					prices[st + num3] = num + _midCoder[posState].GetPrice(num3 - 8);
				}
				for (; num3 < numSymbols; num3++)
				{
					prices[st + num3] = num2 + _highCoder.GetPrice(num3 - 8 - 8);
				}
			}
		}

		private class LenPriceTableEncoder : LenEncoder
		{
			private uint[] _prices = new uint[4352];

			private uint _tableSize;

			private uint[] _counters = new uint[16];

			public void SetTableSize(uint tableSize)
			{
				_tableSize = tableSize;
			}

			public uint GetPrice(uint symbol, uint posState)
			{
				return _prices[posState * 272 + symbol];
			}

			private void UpdateTable(uint posState)
			{
				SetPrices(posState, _tableSize, _prices, posState * 272);
				_counters[posState] = _tableSize;
			}

			public void UpdateTables(uint numPosStates)
			{
				for (uint num = 0u; num < numPosStates; num++)
				{
					UpdateTable(num);
				}
			}

			public new void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, uint symbol, uint posState)
			{
				base.Encode(rangeEncoder, symbol, posState);
				if (--_counters[posState] == 0)
				{
					UpdateTable(posState);
				}
			}
		}

		private class Optimal
		{
			public Base.State State;

			public bool Prev1IsChar;

			public bool Prev2;

			public uint PosPrev2;

			public uint BackPrev2;

			public uint Price;

			public uint PosPrev;

			public uint BackPrev;

			public uint Backs0;

			public uint Backs1;

			public uint Backs2;

			public uint Backs3;

			public void MakeAsChar()
			{
				BackPrev = uint.MaxValue;
				Prev1IsChar = false;
			}

			public void MakeAsShortRep()
			{
				BackPrev = 0u;
				Prev1IsChar = false;
			}

			public bool IsShortRep()
			{
				return BackPrev == 0;
			}
		}

		private const uint kIfinityPrice = 268435455u;

		private static byte[] g_FastPos;

		private Base.State _state = default(Base.State);

		private byte _previousByte;

		private uint[] _repDistances = new uint[4];

		private const int kDefaultDictionaryLogSize = 22;

		private const uint kNumFastBytesDefault = 32u;

		private const uint kNumLenSpecSymbols = 16u;

		private const uint kNumOpts = 4096u;

		private Optimal[] _optimum = new Optimal[4096];

		private IMatchFinder _matchFinder = null;

		private SevenZip.Compression.RangeCoder.Encoder _rangeEncoder = new SevenZip.Compression.RangeCoder.Encoder();

		private BitEncoder[] _isMatch = new BitEncoder[192];

		private BitEncoder[] _isRep = new BitEncoder[12];

		private BitEncoder[] _isRepG0 = new BitEncoder[12];

		private BitEncoder[] _isRepG1 = new BitEncoder[12];

		private BitEncoder[] _isRepG2 = new BitEncoder[12];

		private BitEncoder[] _isRep0Long = new BitEncoder[192];

		private BitTreeEncoder[] _posSlotEncoder = new BitTreeEncoder[4];

		private BitEncoder[] _posEncoders = new BitEncoder[114];

		private BitTreeEncoder _posAlignEncoder = new BitTreeEncoder(4);

		private LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();

		private LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();

		private LiteralEncoder _literalEncoder = new LiteralEncoder();

		private uint[] _matchDistances = new uint[548];

		private uint _numFastBytes = 32u;

		private uint _longestMatchLength;

		private uint _numDistancePairs;

		private uint _additionalOffset;

		private uint _optimumEndIndex;

		private uint _optimumCurrentIndex;

		private bool _longestMatchWasFound;

		private uint[] _posSlotPrices = new uint[256];

		private uint[] _distancesPrices = new uint[512];

		private uint[] _alignPrices = new uint[16];

		private uint _alignPriceCount;

		private uint _distTableSize = 44u;

		private int _posStateBits = 2;

		private uint _posStateMask = 3u;

		private int _numLiteralPosStateBits = 0;

		private int _numLiteralContextBits = 3;

		private uint _dictionarySize = 4194304u;

		private uint _dictionarySizePrev = uint.MaxValue;

		private uint _numFastBytesPrev = uint.MaxValue;

		private long nowPos64;

		private bool _finished;

		private Stream _inStream;

		private EMatchFinderType _matchFinderType = EMatchFinderType.BT4;

		private bool _writeEndMark = false;

		private bool _needReleaseMFStream;

		private uint[] reps = new uint[4];

		private uint[] repLens = new uint[4];

		private const int kPropSize = 5;

		private byte[] properties = new byte[5];

		private uint[] tempPrices = new uint[128];

		private uint _matchPriceCount;

		private static string[] kMatchFinderIDs;

		private uint _trainSize = 0u;

		static Encoder()
		{
			g_FastPos = new byte[2048];
			kMatchFinderIDs = new string[2] { "BT2", "BT4" };
			int num = 2;
			g_FastPos[0] = 0;
			g_FastPos[1] = 1;
			for (byte b = 2; b < 22; b++)
			{
				uint num2 = (uint)(1 << (b >> 1) - 1);
				uint num3 = 0u;
				while (num3 < num2)
				{
					g_FastPos[num] = b;
					num3++;
					num++;
				}
			}
		}

		private static uint GetPosSlot(uint pos)
		{
			if (pos < 2048)
			{
				return g_FastPos[pos];
			}
			if (pos < 2097152)
			{
				return (uint)(g_FastPos[pos >> 10] + 20);
			}
			return (uint)(g_FastPos[pos >> 20] + 40);
		}

		private static uint GetPosSlot2(uint pos)
		{
			if (pos < 131072)
			{
				return (uint)(g_FastPos[pos >> 6] + 12);
			}
			if (pos < 134217728)
			{
				return (uint)(g_FastPos[pos >> 16] + 32);
			}
			return (uint)(g_FastPos[pos >> 26] + 52);
		}

		private void BaseInit()
		{
			_state.Init();
			_previousByte = 0;
			for (uint num = 0u; num < 4; num++)
			{
				_repDistances[num] = 0u;
			}
		}

		private void Create()
		{
			if (_matchFinder == null)
			{
				BinTree binTree = new BinTree();
				int type = 4;
				if (_matchFinderType == EMatchFinderType.BT2)
				{
					type = 2;
				}
				binTree.SetType(type);
				_matchFinder = binTree;
			}
			_literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits);
			if (_dictionarySize != _dictionarySizePrev || _numFastBytesPrev != _numFastBytes)
			{
				_matchFinder.Create(_dictionarySize, 4096u, _numFastBytes, 274u);
				_dictionarySizePrev = _dictionarySize;
				_numFastBytesPrev = _numFastBytes;
			}
		}

		public Encoder()
		{
			for (int i = 0; (long)i < 4096L; i++)
			{
				_optimum[i] = new Optimal();
			}
			for (int j = 0; (long)j < 4L; j++)
			{
				_posSlotEncoder[j] = new BitTreeEncoder(6);
			}
		}

		private void SetWriteEndMarkerMode(bool writeEndMarker)
		{
			_writeEndMark = writeEndMarker;
		}

		private void Init()
		{
			BaseInit();
			_rangeEncoder.Init();
			for (uint num = 0u; num < 12; num++)
			{
				for (uint num2 = 0u; num2 <= _posStateMask; num2++)
				{
					uint num3 = (num << 4) + num2;
					_isMatch[num3].Init();
					_isRep0Long[num3].Init();
				}
				_isRep[num].Init();
				_isRepG0[num].Init();
				_isRepG1[num].Init();
				_isRepG2[num].Init();
			}
			_literalEncoder.Init();
			for (uint num = 0u; num < 4; num++)
			{
				_posSlotEncoder[num].Init();
			}
			for (uint num = 0u; num < 114; num++)
			{
				_posEncoders[num].Init();
			}
			_lenEncoder.Init((uint)(1 << _posStateBits));
			_repMatchLenEncoder.Init((uint)(1 << _posStateBits));
			_posAlignEncoder.Init();
			_longestMatchWasFound = false;
			_optimumEndIndex = 0u;
			_optimumCurrentIndex = 0u;
			_additionalOffset = 0u;
		}

		private void ReadMatchDistances(out uint lenRes, out uint numDistancePairs)
		{
			lenRes = 0u;
			numDistancePairs = _matchFinder.GetMatches(_matchDistances);
			if (numDistancePairs != 0)
			{
				lenRes = _matchDistances[numDistancePairs - 2];
				if (lenRes == _numFastBytes)
				{
					lenRes += _matchFinder.GetMatchLen((int)(lenRes - 1), _matchDistances[numDistancePairs - 1], 273 - lenRes);
				}
			}
			_additionalOffset++;
		}

		private void MovePos(uint num)
		{
			if (num != 0)
			{
				_matchFinder.Skip(num);
				_additionalOffset += num;
			}
		}

		private uint GetRepLen1Price(Base.State state, uint posState)
		{
			return _isRepG0[state.Index].GetPrice0() + _isRep0Long[(state.Index << 4) + posState].GetPrice0();
		}

		private uint GetPureRepPrice(uint repIndex, Base.State state, uint posState)
		{
			uint price;
			if (repIndex == 0)
			{
				price = _isRepG0[state.Index].GetPrice0();
				return price + _isRep0Long[(state.Index << 4) + posState].GetPrice1();
			}
			price = _isRepG0[state.Index].GetPrice1();
			if (repIndex == 1)
			{
				return price + _isRepG1[state.Index].GetPrice0();
			}
			price += _isRepG1[state.Index].GetPrice1();
			return price + _isRepG2[state.Index].GetPrice(repIndex - 2);
		}

		private uint GetRepPrice(uint repIndex, uint len, Base.State state, uint posState)
		{
			uint price = _repMatchLenEncoder.GetPrice(len - 2, posState);
			return price + GetPureRepPrice(repIndex, state, posState);
		}

		private uint GetPosLenPrice(uint pos, uint len, uint posState)
		{
			uint lenToPosState = Base.GetLenToPosState(len);
			uint num = ((pos >= 128) ? (_posSlotPrices[(lenToPosState << 6) + GetPosSlot2(pos)] + _alignPrices[pos & 0xF]) : _distancesPrices[lenToPosState * 128 + pos]);
			return num + _lenEncoder.GetPrice(len - 2, posState);
		}

		private uint Backward(out uint backRes, uint cur)
		{
			_optimumEndIndex = cur;
			uint posPrev = _optimum[cur].PosPrev;
			uint backPrev = _optimum[cur].BackPrev;
			do
			{
				if (_optimum[cur].Prev1IsChar)
				{
					_optimum[posPrev].MakeAsChar();
					_optimum[posPrev].PosPrev = posPrev - 1;
					if (_optimum[cur].Prev2)
					{
						_optimum[posPrev - 1].Prev1IsChar = false;
						_optimum[posPrev - 1].PosPrev = _optimum[cur].PosPrev2;
						_optimum[posPrev - 1].BackPrev = _optimum[cur].BackPrev2;
					}
				}
				uint num = posPrev;
				uint backPrev2 = backPrev;
				backPrev = _optimum[num].BackPrev;
				posPrev = _optimum[num].PosPrev;
				_optimum[num].BackPrev = backPrev2;
				_optimum[num].PosPrev = cur;
				cur = num;
			}
			while (cur != 0);
			backRes = _optimum[0].BackPrev;
			_optimumCurrentIndex = _optimum[0].PosPrev;
			return _optimumCurrentIndex;
		}

		private uint GetOptimum(uint position, out uint backRes)
		{
			if (_optimumEndIndex != _optimumCurrentIndex)
			{
				uint result = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;
				backRes = _optimum[_optimumCurrentIndex].BackPrev;
				_optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;
				return result;
			}
			_optimumCurrentIndex = (_optimumEndIndex = 0u);
			uint lenRes;
			uint numDistancePairs;
			if (!_longestMatchWasFound)
			{
				ReadMatchDistances(out lenRes, out numDistancePairs);
			}
			else
			{
				lenRes = _longestMatchLength;
				numDistancePairs = _numDistancePairs;
				_longestMatchWasFound = false;
			}
			uint num = _matchFinder.GetNumAvailableBytes() + 1;
			if (num < 2)
			{
				backRes = uint.MaxValue;
				return 1u;
			}
			if (num > 273)
			{
				num = 273u;
			}
			uint num2 = 0u;
			for (uint num3 = 0u; num3 < 4; num3++)
			{
				reps[num3] = _repDistances[num3];
				repLens[num3] = _matchFinder.GetMatchLen(-1, reps[num3], 273u);
				if (repLens[num3] > repLens[num2])
				{
					num2 = num3;
				}
			}
			if (repLens[num2] >= _numFastBytes)
			{
				backRes = num2;
				uint num4 = repLens[num2];
				MovePos(num4 - 1);
				return num4;
			}
			if (lenRes >= _numFastBytes)
			{
				backRes = _matchDistances[numDistancePairs - 1] + 4;
				MovePos(lenRes - 1);
				return lenRes;
			}
			byte indexByte = _matchFinder.GetIndexByte(-1);
			byte indexByte2 = _matchFinder.GetIndexByte((int)(0 - _repDistances[0] - 1 - 1));
			if (lenRes < 2 && indexByte != indexByte2 && repLens[num2] < 2)
			{
				backRes = uint.MaxValue;
				return 1u;
			}
			_optimum[0].State = _state;
			uint num5 = position & _posStateMask;
			_optimum[1].Price = _isMatch[(_state.Index << 4) + num5].GetPrice0() + _literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!_state.IsCharState(), indexByte2, indexByte);
			_optimum[1].MakeAsChar();
			uint price = _isMatch[(_state.Index << 4) + num5].GetPrice1();
			uint num6 = price + _isRep[_state.Index].GetPrice1();
			if (indexByte2 == indexByte)
			{
				uint num7 = num6 + GetRepLen1Price(_state, num5);
				if (num7 < _optimum[1].Price)
				{
					_optimum[1].Price = num7;
					_optimum[1].MakeAsShortRep();
				}
			}
			uint num8 = ((lenRes >= repLens[num2]) ? lenRes : repLens[num2]);
			if (num8 < 2)
			{
				backRes = _optimum[1].BackPrev;
				return 1u;
			}
			_optimum[1].PosPrev = 0u;
			_optimum[0].Backs0 = reps[0];
			_optimum[0].Backs1 = reps[1];
			_optimum[0].Backs2 = reps[2];
			_optimum[0].Backs3 = reps[3];
			uint num9 = num8;
			do
			{
				_optimum[num9--].Price = 268435455u;
			}
			while (num9 >= 2);
			for (uint num3 = 0u; num3 < 4; num3++)
			{
				uint num10 = repLens[num3];
				if (num10 < 2)
				{
					continue;
				}
				uint num11 = num6 + GetPureRepPrice(num3, _state, num5);
				do
				{
					uint num12 = num11 + _repMatchLenEncoder.GetPrice(num10 - 2, num5);
					Optimal optimal = _optimum[num10];
					if (num12 < optimal.Price)
					{
						optimal.Price = num12;
						optimal.PosPrev = 0u;
						optimal.BackPrev = num3;
						optimal.Prev1IsChar = false;
					}
				}
				while (--num10 >= 2);
			}
			uint num13 = price + _isRep[_state.Index].GetPrice0();
			num9 = ((repLens[0] >= 2) ? (repLens[0] + 1) : 2u);
			if (num9 <= lenRes)
			{
				uint num14;
				for (num14 = 0u; num9 > _matchDistances[num14]; num14 += 2)
				{
				}
				while (true)
				{
					uint num15 = _matchDistances[num14 + 1];
					uint num16 = num13 + GetPosLenPrice(num15, num9, num5);
					Optimal optimal2 = _optimum[num9];
					if (num16 < optimal2.Price)
					{
						optimal2.Price = num16;
						optimal2.PosPrev = 0u;
						optimal2.BackPrev = num15 + 4;
						optimal2.Prev1IsChar = false;
					}
					if (num9 == _matchDistances[num14])
					{
						num14 += 2;
						if (num14 == numDistancePairs)
						{
							break;
						}
					}
					num9++;
				}
			}
			uint num17 = 0u;
			uint lenRes2;
			while (true)
			{
				num17++;
				if (num17 == num8)
				{
					return Backward(out backRes, num17);
				}
				ReadMatchDistances(out lenRes2, out numDistancePairs);
				if (lenRes2 >= _numFastBytes)
				{
					break;
				}
				position++;
				uint num18 = _optimum[num17].PosPrev;
				Base.State state;
				if (_optimum[num17].Prev1IsChar)
				{
					num18--;
					if (_optimum[num17].Prev2)
					{
						state = _optimum[_optimum[num17].PosPrev2].State;
						if (_optimum[num17].BackPrev2 < 4)
						{
							state.UpdateRep();
						}
						else
						{
							state.UpdateMatch();
						}
					}
					else
					{
						state = _optimum[num18].State;
					}
					state.UpdateChar();
				}
				else
				{
					state = _optimum[num18].State;
				}
				if (num18 == num17 - 1)
				{
					if (_optimum[num17].IsShortRep())
					{
						state.UpdateShortRep();
					}
					else
					{
						state.UpdateChar();
					}
				}
				else
				{
					uint num19;
					if (_optimum[num17].Prev1IsChar && _optimum[num17].Prev2)
					{
						num18 = _optimum[num17].PosPrev2;
						num19 = _optimum[num17].BackPrev2;
						state.UpdateRep();
					}
					else
					{
						num19 = _optimum[num17].BackPrev;
						if (num19 < 4)
						{
							state.UpdateRep();
						}
						else
						{
							state.UpdateMatch();
						}
					}
					Optimal optimal3 = _optimum[num18];
					switch (num19)
					{
					case 0u:
						reps[0] = optimal3.Backs0;
						reps[1] = optimal3.Backs1;
						reps[2] = optimal3.Backs2;
						reps[3] = optimal3.Backs3;
						break;
					case 1u:
						reps[0] = optimal3.Backs1;
						reps[1] = optimal3.Backs0;
						reps[2] = optimal3.Backs2;
						reps[3] = optimal3.Backs3;
						break;
					case 2u:
						reps[0] = optimal3.Backs2;
						reps[1] = optimal3.Backs0;
						reps[2] = optimal3.Backs1;
						reps[3] = optimal3.Backs3;
						break;
					case 3u:
						reps[0] = optimal3.Backs3;
						reps[1] = optimal3.Backs0;
						reps[2] = optimal3.Backs1;
						reps[3] = optimal3.Backs2;
						break;
					default:
						reps[0] = num19 - 4;
						reps[1] = optimal3.Backs0;
						reps[2] = optimal3.Backs1;
						reps[3] = optimal3.Backs2;
						break;
					}
				}
				_optimum[num17].State = state;
				_optimum[num17].Backs0 = reps[0];
				_optimum[num17].Backs1 = reps[1];
				_optimum[num17].Backs2 = reps[2];
				_optimum[num17].Backs3 = reps[3];
				uint price2 = _optimum[num17].Price;
				indexByte = _matchFinder.GetIndexByte(-1);
				indexByte2 = _matchFinder.GetIndexByte((int)(0 - reps[0] - 1 - 1));
				num5 = position & _posStateMask;
				uint num20 = price2 + _isMatch[(state.Index << 4) + num5].GetPrice0() + _literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(-2)).GetPrice(!state.IsCharState(), indexByte2, indexByte);
				Optimal optimal4 = _optimum[num17 + 1];
				bool flag = false;
				if (num20 < optimal4.Price)
				{
					optimal4.Price = num20;
					optimal4.PosPrev = num17;
					optimal4.MakeAsChar();
					flag = true;
				}
				price = price2 + _isMatch[(state.Index << 4) + num5].GetPrice1();
				num6 = price + _isRep[state.Index].GetPrice1();
				if (indexByte2 == indexByte && (optimal4.PosPrev >= num17 || optimal4.BackPrev != 0))
				{
					uint num21 = num6 + GetRepLen1Price(state, num5);
					if (num21 <= optimal4.Price)
					{
						optimal4.Price = num21;
						optimal4.PosPrev = num17;
						optimal4.MakeAsShortRep();
						flag = true;
					}
				}
				uint val = _matchFinder.GetNumAvailableBytes() + 1;
				val = Math.Min(4095 - num17, val);
				num = val;
				if (num < 2)
				{
					continue;
				}
				if (num > _numFastBytes)
				{
					num = _numFastBytes;
				}
				if (!flag && indexByte2 != indexByte)
				{
					uint limit = Math.Min(val - 1, _numFastBytes);
					uint matchLen = _matchFinder.GetMatchLen(0, reps[0], limit);
					if (matchLen >= 2)
					{
						Base.State state2 = state;
						state2.UpdateChar();
						uint num22 = (position + 1) & _posStateMask;
						uint num23 = num20 + _isMatch[(state2.Index << 4) + num22].GetPrice1() + _isRep[state2.Index].GetPrice1();
						uint num24 = num17 + 1 + matchLen;
						while (num8 < num24)
						{
							_optimum[++num8].Price = 268435455u;
						}
						uint num25 = num23 + GetRepPrice(0u, matchLen, state2, num22);
						Optimal optimal5 = _optimum[num24];
						if (num25 < optimal5.Price)
						{
							optimal5.Price = num25;
							optimal5.PosPrev = num17 + 1;
							optimal5.BackPrev = 0u;
							optimal5.Prev1IsChar = true;
							optimal5.Prev2 = false;
						}
					}
				}
				uint num26 = 2u;
				for (uint num27 = 0u; num27 < 4; num27++)
				{
					uint num28 = _matchFinder.GetMatchLen(-1, reps[num27], num);
					if (num28 < 2)
					{
						continue;
					}
					uint num29 = num28;
					while (true)
					{
						if (num8 < num17 + num28)
						{
							_optimum[++num8].Price = 268435455u;
							continue;
						}
						uint num30 = num6 + GetRepPrice(num27, num28, state, num5);
						Optimal optimal6 = _optimum[num17 + num28];
						if (num30 < optimal6.Price)
						{
							optimal6.Price = num30;
							optimal6.PosPrev = num17;
							optimal6.BackPrev = num27;
							optimal6.Prev1IsChar = false;
						}
						if (--num28 < 2)
						{
							break;
						}
					}
					num28 = num29;
					if (num27 == 0)
					{
						num26 = num28 + 1;
					}
					if (num28 >= val)
					{
						continue;
					}
					uint limit2 = Math.Min(val - 1 - num28, _numFastBytes);
					uint matchLen2 = _matchFinder.GetMatchLen((int)num28, reps[num27], limit2);
					if (matchLen2 >= 2)
					{
						Base.State state3 = state;
						state3.UpdateRep();
						uint num31 = (position + num28) & _posStateMask;
						uint num32 = num6 + GetRepPrice(num27, num28, state, num5) + _isMatch[(state3.Index << 4) + num31].GetPrice0() + _literalEncoder.GetSubCoder(position + num28, _matchFinder.GetIndexByte((int)(num28 - 1 - 1))).GetPrice(matchMode: true, _matchFinder.GetIndexByte((int)(num28 - 1 - (reps[num27] + 1))), _matchFinder.GetIndexByte((int)(num28 - 1)));
						state3.UpdateChar();
						num31 = (position + num28 + 1) & _posStateMask;
						uint num33 = num32 + _isMatch[(state3.Index << 4) + num31].GetPrice1();
						uint num34 = num33 + _isRep[state3.Index].GetPrice1();
						uint num35 = num28 + 1 + matchLen2;
						while (num8 < num17 + num35)
						{
							_optimum[++num8].Price = 268435455u;
						}
						uint num36 = num34 + GetRepPrice(0u, matchLen2, state3, num31);
						Optimal optimal7 = _optimum[num17 + num35];
						if (num36 < optimal7.Price)
						{
							optimal7.Price = num36;
							optimal7.PosPrev = num17 + num28 + 1;
							optimal7.BackPrev = 0u;
							optimal7.Prev1IsChar = true;
							optimal7.Prev2 = true;
							optimal7.PosPrev2 = num17;
							optimal7.BackPrev2 = num27;
						}
					}
				}
				if (lenRes2 > num)
				{
					lenRes2 = num;
					for (numDistancePairs = 0u; lenRes2 > _matchDistances[numDistancePairs]; numDistancePairs += 2)
					{
					}
					_matchDistances[numDistancePairs] = lenRes2;
					numDistancePairs += 2;
				}
				if (lenRes2 < num26)
				{
					continue;
				}
				num13 = price + _isRep[state.Index].GetPrice0();
				while (num8 < num17 + lenRes2)
				{
					_optimum[++num8].Price = 268435455u;
				}
				uint num37;
				for (num37 = 0u; num26 > _matchDistances[num37]; num37 += 2)
				{
				}
				uint num38 = num26;
				while (true)
				{
					uint num39 = _matchDistances[num37 + 1];
					uint num40 = num13 + GetPosLenPrice(num39, num38, num5);
					Optimal optimal8 = _optimum[num17 + num38];
					if (num40 < optimal8.Price)
					{
						optimal8.Price = num40;
						optimal8.PosPrev = num17;
						optimal8.BackPrev = num39 + 4;
						optimal8.Prev1IsChar = false;
					}
					if (num38 == _matchDistances[num37])
					{
						if (num38 < val)
						{
							uint limit3 = Math.Min(val - 1 - num38, _numFastBytes);
							uint matchLen3 = _matchFinder.GetMatchLen((int)num38, num39, limit3);
							if (matchLen3 >= 2)
							{
								Base.State state4 = state;
								state4.UpdateMatch();
								uint num41 = (position + num38) & _posStateMask;
								uint num42 = num40 + _isMatch[(state4.Index << 4) + num41].GetPrice0() + _literalEncoder.GetSubCoder(position + num38, _matchFinder.GetIndexByte((int)(num38 - 1 - 1))).GetPrice(matchMode: true, _matchFinder.GetIndexByte((int)(num38 - (num39 + 1) - 1)), _matchFinder.GetIndexByte((int)(num38 - 1)));
								state4.UpdateChar();
								num41 = (position + num38 + 1) & _posStateMask;
								uint num43 = num42 + _isMatch[(state4.Index << 4) + num41].GetPrice1();
								uint num44 = num43 + _isRep[state4.Index].GetPrice1();
								uint num45 = num38 + 1 + matchLen3;
								while (num8 < num17 + num45)
								{
									_optimum[++num8].Price = 268435455u;
								}
								num40 = num44 + GetRepPrice(0u, matchLen3, state4, num41);
								optimal8 = _optimum[num17 + num45];
								if (num40 < optimal8.Price)
								{
									optimal8.Price = num40;
									optimal8.PosPrev = num17 + num38 + 1;
									optimal8.BackPrev = 0u;
									optimal8.Prev1IsChar = true;
									optimal8.Prev2 = true;
									optimal8.PosPrev2 = num17;
									optimal8.BackPrev2 = num39 + 4;
								}
							}
						}
						num37 += 2;
						if (num37 == numDistancePairs)
						{
							break;
						}
					}
					num38++;
				}
			}
			_numDistancePairs = numDistancePairs;
			_longestMatchLength = lenRes2;
			_longestMatchWasFound = true;
			return Backward(out backRes, num17);
		}

		private bool ChangePair(uint smallDist, uint bigDist)
		{
			return smallDist < 33554432 && bigDist >= smallDist << 7;
		}

		private void WriteEndMarker(uint posState)
		{
			if (_writeEndMark)
			{
				_isMatch[(_state.Index << 4) + posState].Encode(_rangeEncoder, 1u);
				_isRep[_state.Index].Encode(_rangeEncoder, 0u);
				_state.UpdateMatch();
				uint num = 2u;
				_lenEncoder.Encode(_rangeEncoder, num - 2, posState);
				uint symbol = 63u;
				uint lenToPosState = Base.GetLenToPosState(num);
				_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, symbol);
				int num2 = 30;
				uint num3 = (uint)((1 << num2) - 1);
				_rangeEncoder.EncodeDirectBits(num3 >> 4, num2 - 4);
				_posAlignEncoder.ReverseEncode(_rangeEncoder, num3 & 0xFu);
			}
		}

		private void Flush(uint nowPos)
		{
			ReleaseMFStream();
			WriteEndMarker(nowPos & _posStateMask);
			_rangeEncoder.FlushData();
			_rangeEncoder.FlushStream();
		}

		public void CodeOneBlock(out long inSize, out long outSize, out bool finished)
		{
			inSize = 0L;
			outSize = 0L;
			finished = true;
			if (_inStream != null)
			{
				_matchFinder.SetStream(_inStream);
				_matchFinder.Init();
				_needReleaseMFStream = true;
				_inStream = null;
				if (_trainSize != 0)
				{
					_matchFinder.Skip(_trainSize);
				}
			}
			if (_finished)
			{
				return;
			}
			_finished = true;
			long num = nowPos64;
			if (nowPos64 == 0)
			{
				if (_matchFinder.GetNumAvailableBytes() == 0)
				{
					Flush((uint)nowPos64);
					return;
				}
				ReadMatchDistances(out var _, out var _);
				uint num2 = (uint)(int)nowPos64 & _posStateMask;
				_isMatch[(_state.Index << 4) + num2].Encode(_rangeEncoder, 0u);
				_state.UpdateChar();
				byte indexByte = _matchFinder.GetIndexByte((int)(0 - _additionalOffset));
				_literalEncoder.GetSubCoder((uint)nowPos64, _previousByte).Encode(_rangeEncoder, indexByte);
				_previousByte = indexByte;
				_additionalOffset--;
				nowPos64++;
			}
			if (_matchFinder.GetNumAvailableBytes() == 0)
			{
				Flush((uint)nowPos64);
				return;
			}
			while (true)
			{
				uint backRes;
				uint optimum = GetOptimum((uint)nowPos64, out backRes);
				uint num3 = (uint)(int)nowPos64 & _posStateMask;
				uint num4 = (_state.Index << 4) + num3;
				if (optimum == 1 && backRes == uint.MaxValue)
				{
					_isMatch[num4].Encode(_rangeEncoder, 0u);
					byte indexByte2 = _matchFinder.GetIndexByte((int)(0 - _additionalOffset));
					LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((uint)nowPos64, _previousByte);
					if (!_state.IsCharState())
					{
						byte indexByte3 = _matchFinder.GetIndexByte((int)(0 - _repDistances[0] - 1 - _additionalOffset));
						subCoder.EncodeMatched(_rangeEncoder, indexByte3, indexByte2);
					}
					else
					{
						subCoder.Encode(_rangeEncoder, indexByte2);
					}
					_previousByte = indexByte2;
					_state.UpdateChar();
				}
				else
				{
					_isMatch[num4].Encode(_rangeEncoder, 1u);
					if (backRes < 4)
					{
						_isRep[_state.Index].Encode(_rangeEncoder, 1u);
						if (backRes == 0)
						{
							_isRepG0[_state.Index].Encode(_rangeEncoder, 0u);
							if (optimum == 1)
							{
								_isRep0Long[num4].Encode(_rangeEncoder, 0u);
							}
							else
							{
								_isRep0Long[num4].Encode(_rangeEncoder, 1u);
							}
						}
						else
						{
							_isRepG0[_state.Index].Encode(_rangeEncoder, 1u);
							if (backRes == 1)
							{
								_isRepG1[_state.Index].Encode(_rangeEncoder, 0u);
							}
							else
							{
								_isRepG1[_state.Index].Encode(_rangeEncoder, 1u);
								_isRepG2[_state.Index].Encode(_rangeEncoder, backRes - 2);
							}
						}
						if (optimum == 1)
						{
							_state.UpdateShortRep();
						}
						else
						{
							_repMatchLenEncoder.Encode(_rangeEncoder, optimum - 2, num3);
							_state.UpdateRep();
						}
						uint num5 = _repDistances[backRes];
						if (backRes != 0)
						{
							for (uint num6 = backRes; num6 >= 1; num6--)
							{
								_repDistances[num6] = _repDistances[num6 - 1];
							}
							_repDistances[0] = num5;
						}
					}
					else
					{
						_isRep[_state.Index].Encode(_rangeEncoder, 0u);
						_state.UpdateMatch();
						_lenEncoder.Encode(_rangeEncoder, optimum - 2, num3);
						backRes -= 4;
						uint posSlot = GetPosSlot(backRes);
						uint lenToPosState = Base.GetLenToPosState(optimum);
						_posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
						if (posSlot >= 4)
						{
							int num7 = (int)((posSlot >> 1) - 1);
							uint num8 = (2 | (posSlot & 1)) << num7;
							uint num9 = backRes - num8;
							if (posSlot < 14)
							{
								BitTreeEncoder.ReverseEncode(_posEncoders, num8 - posSlot - 1, _rangeEncoder, num7, num9);
							}
							else
							{
								_rangeEncoder.EncodeDirectBits(num9 >> 4, num7 - 4);
								_posAlignEncoder.ReverseEncode(_rangeEncoder, num9 & 0xFu);
								_alignPriceCount++;
							}
						}
						uint num10 = backRes;
						for (uint num11 = 3u; num11 >= 1; num11--)
						{
							_repDistances[num11] = _repDistances[num11 - 1];
						}
						_repDistances[0] = num10;
						_matchPriceCount++;
					}
					_previousByte = _matchFinder.GetIndexByte((int)(optimum - 1 - _additionalOffset));
				}
				_additionalOffset -= optimum;
				nowPos64 += optimum;
				if (_additionalOffset == 0)
				{
					if (_matchPriceCount >= 128)
					{
						FillDistancesPrices();
					}
					if (_alignPriceCount >= 16)
					{
						FillAlignPrices();
					}
					inSize = nowPos64;
					outSize = _rangeEncoder.GetProcessedSizeAdd();
					if (_matchFinder.GetNumAvailableBytes() == 0)
					{
						Flush((uint)nowPos64);
						return;
					}
					if (nowPos64 - num >= 4096)
					{
						break;
					}
				}
			}
			_finished = false;
			finished = false;
		}

		private void ReleaseMFStream()
		{
			if (_matchFinder != null && _needReleaseMFStream)
			{
				_matchFinder.ReleaseStream();
				_needReleaseMFStream = false;
			}
		}

		private void SetOutStream(Stream outStream)
		{
			_rangeEncoder.SetStream(outStream);
		}

		private void ReleaseOutStream()
		{
			_rangeEncoder.ReleaseStream();
		}

		private void ReleaseStreams()
		{
			ReleaseMFStream();
			ReleaseOutStream();
		}

		private void SetStreams(Stream inStream, Stream outStream, long inSize, long outSize)
		{
			_inStream = inStream;
			_finished = false;
			Create();
			SetOutStream(outStream);
			Init();
			FillDistancesPrices();
			FillAlignPrices();
			_lenEncoder.SetTableSize(_numFastBytes + 1 - 2);
			_lenEncoder.UpdateTables((uint)(1 << _posStateBits));
			_repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - 2);
			_repMatchLenEncoder.UpdateTables((uint)(1 << _posStateBits));
			nowPos64 = 0L;
		}

		public void Code(Stream inStream, Stream outStream, long inSize, long outSize, ICodeProgress progress)
		{
			_needReleaseMFStream = false;
			try
			{
				SetStreams(inStream, outStream, inSize, outSize);
				while (true)
				{
					CodeOneBlock(out var inSize2, out var outSize2, out var finished);
					if (finished)
					{
						break;
					}
					progress?.SetProgress(inSize2, outSize2);
				}
			}
			finally
			{
				ReleaseStreams();
			}
		}

		public void WriteCoderProperties(Stream outStream)
		{
			properties[0] = (byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
			for (int i = 0; i < 4; i++)
			{
				properties[1 + i] = (byte)((_dictionarySize >> 8 * i) & 0xFFu);
			}
			outStream.Write(properties, 0, 5);
		}

		private void FillDistancesPrices()
		{
			for (uint num = 4u; num < 128; num++)
			{
				uint posSlot = GetPosSlot(num);
				int num2 = (int)((posSlot >> 1) - 1);
				uint num3 = (2 | (posSlot & 1)) << num2;
				tempPrices[num] = BitTreeEncoder.ReverseGetPrice(_posEncoders, num3 - posSlot - 1, num2, num - num3);
			}
			for (uint num4 = 0u; num4 < 4; num4++)
			{
				BitTreeEncoder bitTreeEncoder = _posSlotEncoder[num4];
				uint num5 = num4 << 6;
				for (uint num6 = 0u; num6 < _distTableSize; num6++)
				{
					_posSlotPrices[num5 + num6] = bitTreeEncoder.GetPrice(num6);
				}
				for (uint num6 = 14u; num6 < _distTableSize; num6++)
				{
					_posSlotPrices[num5 + num6] += (num6 >> 1) - 1 - 4 << 6;
				}
				uint num7 = num4 * 128;
				uint num8;
				for (num8 = 0u; num8 < 4; num8++)
				{
					_distancesPrices[num7 + num8] = _posSlotPrices[num5 + num8];
				}
				for (; num8 < 128; num8++)
				{
					_distancesPrices[num7 + num8] = _posSlotPrices[num5 + GetPosSlot(num8)] + tempPrices[num8];
				}
			}
			_matchPriceCount = 0u;
		}

		private void FillAlignPrices()
		{
			for (uint num = 0u; num < 16; num++)
			{
				_alignPrices[num] = _posAlignEncoder.ReverseGetPrice(num);
			}
			_alignPriceCount = 0u;
		}

		private static int FindMatchFinder(string s)
		{
			for (int i = 0; i < kMatchFinderIDs.Length; i++)
			{
				if (s == kMatchFinderIDs[i])
				{
					return i;
				}
			}
			return -1;
		}

		public void SetCoderProperties(CoderPropID[] propIDs, object[] properties)
		{
			for (uint num = 0u; num < properties.Length; num++)
			{
				object obj = properties[num];
				switch (propIDs[num])
				{
				case CoderPropID.NumFastBytes:
					if (!(obj is int num2))
					{
						throw new InvalidParamException();
					}
					if (num2 < 5 || (long)num2 > 273L)
					{
						throw new InvalidParamException();
					}
					_numFastBytes = (uint)num2;
					break;
				case CoderPropID.MatchFinder:
				{
					if (!(obj is string))
					{
						throw new InvalidParamException();
					}
					EMatchFinderType matchFinderType = _matchFinderType;
					int num6 = FindMatchFinder(((string)obj).ToUpper());
					if (num6 < 0)
					{
						throw new InvalidParamException();
					}
					_matchFinderType = (EMatchFinderType)num6;
					if (_matchFinder != null && matchFinderType != _matchFinderType)
					{
						_dictionarySizePrev = uint.MaxValue;
						_matchFinder = null;
					}
					break;
				}
				case CoderPropID.DictionarySize:
				{
					if (!(obj is int num7))
					{
						throw new InvalidParamException();
					}
					if ((long)num7 < 1L || (long)num7 > 1073741824L)
					{
						throw new InvalidParamException();
					}
					_dictionarySize = (uint)num7;
					int i;
					for (i = 0; (long)i < 30L && num7 > (uint)(1 << i); i++)
					{
					}
					_distTableSize = (uint)(i * 2);
					break;
				}
				case CoderPropID.PosStateBits:
					if (!(obj is int num3))
					{
						throw new InvalidParamException();
					}
					if (num3 < 0 || (long)num3 > 4L)
					{
						throw new InvalidParamException();
					}
					_posStateBits = num3;
					_posStateMask = (uint)((1 << _posStateBits) - 1);
					break;
				case CoderPropID.LitPosBits:
					if (!(obj is int num5))
					{
						throw new InvalidParamException();
					}
					if (num5 < 0 || (long)num5 > 4L)
					{
						throw new InvalidParamException();
					}
					_numLiteralPosStateBits = num5;
					break;
				case CoderPropID.LitContextBits:
					if (!(obj is int num4))
					{
						throw new InvalidParamException();
					}
					if (num4 < 0 || (long)num4 > 8L)
					{
						throw new InvalidParamException();
					}
					_numLiteralContextBits = num4;
					break;
				case CoderPropID.EndMarker:
					if (!(obj is bool))
					{
						throw new InvalidParamException();
					}
					SetWriteEndMarkerMode((bool)obj);
					break;
				default:
					throw new InvalidParamException();
				case CoderPropID.Algorithm:
					break;
				}
			}
		}

		public void SetTrainSize(uint trainSize)
		{
			_trainSize = trainSize;
		}
	}
	public static class SevenZipHelper
	{
		private static CoderPropID[] propIDs = new CoderPropID[8]
		{
			CoderPropID.DictionarySize,
			CoderPropID.PosStateBits,
			CoderPropID.LitContextBits,
			CoderPropID.LitPosBits,
			CoderPropID.Algorithm,
			CoderPropID.NumFastBytes,
			CoderPropID.MatchFinder,
			CoderPropID.EndMarker
		};

		private static object[] properties = new object[8] { 2097152, 2, 3, 0, 2, 32, "bt4", false };

		public static byte[] Compress(byte[] inputBytes, ICodeProgress progress = null)
		{
			MemoryStream inStream = new MemoryStream(inputBytes);
			MemoryStream memoryStream = new MemoryStream();
			Compress(inStream, memoryStream, progress);
			return memoryStream.ToArray();
		}

		public static void Compress(Stream inStream, Stream outStream, ICodeProgress progress = null)
		{
			Encoder encoder = new Encoder();
			encoder.SetCoderProperties(propIDs, properties);
			encoder.WriteCoderProperties(outStream);
			encoder.Code(inStream, outStream, -1L, -1L, progress);
		}

		public static byte[] Decompress(byte[] inputBytes)
		{
			MemoryStream memoryStream = new MemoryStream(inputBytes);
			Decoder decoder = new Decoder();
			memoryStream.Seek(0L, SeekOrigin.Begin);
			MemoryStream memoryStream2 = new MemoryStream();
			byte[] array = new byte[5];
			if (memoryStream.Read(array, 0, 5) != 5)
			{
				throw new Exception("input .lzma is too short");
			}
			long num = 0L;
			for (int i = 0; i < 8; i++)
			{
				int num2 = memoryStream.ReadByte();
				if (num2 < 0)
				{
					throw new Exception("Can't Read 1");
				}
				num |= (long)((ulong)(byte)num2 << 8 * i);
			}
			decoder.SetDecoderProperties(array);
			long inSize = memoryStream.Length - memoryStream.Position;
			decoder.Code(memoryStream, memoryStream2, inSize, num, null);
			return memoryStream2.ToArray();
		}

		public static MemoryStream StreamDecompress(MemoryStream newInStream)
		{
			Decoder decoder = new Decoder();
			newInStream.Seek(0L, SeekOrigin.Begin);
			MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[5];
			if (newInStream.Read(array, 0, 5) != 5)
			{
				throw new Exception("input .lzma is too short");
			}
			long num = 0L;
			for (int i = 0; i < 8; i++)
			{
				int num2 = newInStream.ReadByte();
				if (num2 < 0)
				{
					throw new Exception("Can't Read 1");
				}
				num |= (long)((ulong)(byte)num2 << 8 * i);
			}
			decoder.SetDecoderProperties(array);
			long inSize = newInStream.Length - newInStream.Position;
			decoder.Code(newInStream, memoryStream, inSize, num, null);
			memoryStream.Position = 0L;
			return memoryStream;
		}

		public static MemoryStream StreamDecompress(MemoryStream newInStream, long outSize)
		{
			Decoder decoder = new Decoder();
			newInStream.Seek(0L, SeekOrigin.Begin);
			MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[5];
			if (newInStream.Read(array, 0, 5) != 5)
			{
				throw new Exception("input .lzma is too short");
			}
			decoder.SetDecoderProperties(array);
			long inSize = newInStream.Length - newInStream.Position;
			decoder.Code(newInStream, memoryStream, inSize, outSize, null);
			memoryStream.Position = 0L;
			return memoryStream;
		}

		public static void StreamDecompress(Stream compressedStream, Stream decompressedStream, long compressedSize, long decompressedSize)
		{
			long position = compressedStream.Position;
			Decoder decoder = new Decoder();
			byte[] array = new byte[5];
			if (compressedStream.Read(array, 0, 5) != 5)
			{
				throw new Exception("input .lzma is too short");
			}
			decoder.SetDecoderProperties(array);
			decoder.Code(compressedStream, decompressedStream, compressedSize - 5, decompressedSize, null);
			compressedStream.Position = position + compressedSize;
		}
	}
}
namespace SevenZip.Buffer
{
	public class InBuffer
	{
		private byte[] m_Buffer;

		private uint m_Pos;

		private uint m_Limit;

		private uint m_BufferSize;

		private Stream m_Stream;

		private bool m_StreamWasExhausted;

		private ulong m_ProcessedSize;

		public InBuffer(uint bufferSize)
		{
			m_Buffer = new byte[bufferSize];
			m_BufferSize = bufferSize;
		}

		public void Init(Stream stream)
		{
			m_Stream = stream;
			m_ProcessedSize = 0uL;
			m_Limit = 0u;
			m_Pos = 0u;
			m_StreamWasExhausted = false;
		}

		public bool ReadBlock()
		{
			if (m_StreamWasExhausted)
			{
				return false;
			}
			m_ProcessedSize += m_Pos;
			int num = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
			m_Pos = 0u;
			m_Limit = (uint)num;
			m_StreamWasExhausted = num == 0;
			return !m_StreamWasExhausted;
		}

		public void ReleaseStream()
		{
			m_Stream = null;
		}

		public bool ReadByte(byte b)
		{
			if (m_Pos >= m_Limit && !ReadBlock())
			{
				return false;
			}
			b = m_Buffer[m_Pos++];
			return true;
		}

		public byte ReadByte()
		{
			if (m_Pos >= m_Limit && !ReadBlock())
			{
				return byte.MaxValue;
			}
			return m_Buffer[m_Pos++];
		}

		public ulong GetProcessedSize()
		{
			return m_ProcessedSize + m_Pos;
		}
	}
	public class OutBuffer
	{
		private byte[] m_Buffer;

		private uint m_Pos;

		private uint m_BufferSize;

		private Stream m_Stream;

		private ulong m_ProcessedSize;

		public OutBuffer(uint bufferSize)
		{
			m_Buffer = new byte[bufferSize];
			m_BufferSize = bufferSize;
		}

		public void SetStream(Stream stream)
		{
			m_Stream = stream;
		}

		public void FlushStream()
		{
			m_Stream.Flush();
		}

		public void CloseStream()
		{
			m_Stream.Close();
		}

		public void ReleaseStream()
		{
			m_Stream = null;
		}

		public void Init()
		{
			m_ProcessedSize = 0uL;
			m_Pos = 0u;
		}

		public void WriteByte(byte b)
		{
			m_Buffer[m_Pos++] = b;
			if (m_Pos >= m_BufferSize)
			{
				FlushData();
			}
		}

		public void FlushData()
		{
			if (m_Pos != 0)
			{
				m_Stream.Write(m_Buffer, 0, (int)m_Pos);
				m_Pos = 0u;
			}
		}

		public ulong GetProcessedSize()
		{
			return m_ProcessedSize + m_Pos;
		}
	}
}
namespace SevenZip.CommandLineParser
{
	public enum SwitchType
	{
		Simple,
		PostMinus,
		LimitedPostString,
		UnLimitedPostString,
		PostChar
	}
	public class SwitchForm
	{
		public string IDString;

		public SwitchType Type;

		public bool Multi;

		public int MinLen;

		public int MaxLen;

		public string PostCharSet;

		public SwitchForm(string idString, SwitchType type, bool multi, int minLen, int maxLen, string postCharSet)
		{
			IDString = idString;
			Type = type;
			Multi = multi;
			MinLen = minLen;
			MaxLen = maxLen;
			PostCharSet = postCharSet;
		}

		public SwitchForm(string idString, SwitchType type, bool multi, int minLen)
			: this(idString, type, multi, minLen, 0, "")
		{
		}

		public SwitchForm(string idString, SwitchType type, bool multi)
			: this(idString, type, multi, 0)
		{
		}
	}
	public class SwitchResult
	{
		public bool ThereIs;

		public bool WithMinus;

		public ArrayList PostStrings = new ArrayList();

		public int PostCharIndex;

		public SwitchResult()
		{
			ThereIs = false;
		}
	}
	public class Parser
	{
		public ArrayList NonSwitchStrings = new ArrayList();

		private SwitchResult[] _switches;

		private const char kSwitchID1 = '-';

		private const char kSwitchID2 = '/';

		private const char kSwitchMinus = '-';

		private const string kStopSwitchParsing = "--";

		public SwitchResult this[int index] => _switches[index];

		public Parser(int numSwitches)
		{
			_switches = new SwitchResult[numSwitches];
			for (int i = 0; i < numSwitches; i++)
			{
				_switches[i] = new SwitchResult();
			}
		}

		private bool ParseString(string srcString, SwitchForm[] switchForms)
		{
			int length = srcString.Length;
			if (length == 0)
			{
				return false;
			}
			int num = 0;
			if (!IsItSwitchChar(srcString[num]))
			{
				return false;
			}
			while (num < length)
			{
				if (IsItSwitchChar(srcString[num]))
				{
					num++;
				}
				int num2 = 0;
				int num3 = -1;
				for (int i = 0; i < _switches.Length; i++)
				{
					int length2 = switchForms[i].IDString.Length;
					if (length2 > num3 && num + length2 <= length && string.Compare(switchForms[i].IDString, 0, srcString, num, length2, ignoreCase: true) == 0)
					{
						num2 = i;
						num3 = length2;
					}
				}
				if (num3 == -1)
				{
					throw new Exception("maxLen == kNoLen");
				}
				SwitchResult switchResult = _switches[num2];
				SwitchForm switchForm = switchForms[num2];
				if (!switchForm.Multi && switchResult.ThereIs)
				{
					throw new Exception("switch must be single");
				}
				switchResult.ThereIs = true;
				num += num3;
				int num4 = length - num;
				SwitchType type = switchForm.Type;
				switch (type)
				{
				case SwitchType.PostMinus:
					if (num4 == 0)
					{
						switchResult.WithMinus = false;
						break;
					}
					switchResult.WithMinus = srcString[num] == '-';
					if (switchResult.WithMinus)
					{
						num++;
					}
					break;
				case SwitchType.PostChar:
				{
					if (num4 < switchForm.MinLen)
					{
						throw new Exception("switch is not full");
					}
					string postCharSet = switchForm.PostCharSet;
					if (num4 == 0)
					{
						switchResult.PostCharIndex = -1;
						break;
					}
					int num6 = postCharSet.IndexOf(srcString[num]);
					if (num6 < 0)
					{
						switchResult.PostCharIndex = -1;
						break;
					}
					switchResult.PostCharIndex = num6;
					num++;
					break;
				}
				case SwitchType.LimitedPostString:
				case SwitchType.UnLimitedPostString:
				{
					int minLen = switchForm.MinLen;
					if (num4 < minLen)
					{
						throw new Exception("switch is not full");
					}
					if (type == SwitchType.UnLimitedPostString)
					{
						switchResult.PostStrings.Add(srcString.Substring(num));
						return true;
					}
					string text = srcString.Substring(num, minLen);
					num += minLen;
					int num5 = minLen;
					while (num5 < switchForm.MaxLen && num < length)
					{
						char c = srcString[num];
						if (IsItSwitchChar(c))
						{
							break;
						}
						text += c;
						num5++;
						num++;
					}
					switchResult.PostStrings.Add(text);
					break;
				}
				}
			}
			return true;
		}

		public void ParseStrings(SwitchForm[] switchForms, string[] commandStrings)
		{
			int num = commandStrings.Length;
			bool flag = false;
			for (int i = 0; i < num; i++)
			{
				string text = commandStrings[i];
				if (flag)
				{
					NonSwitchStrings.Add(text);
				}
				else if (text == "--")
				{
					flag = true;
				}
				else if (!ParseString(text, switchForms))
				{
					NonSwitchStrings.Add(text);
				}
			}
		}

		public static int ParseCommand(CommandForm[] commandForms, string commandString, out string postString)
		{
			for (int i = 0; i < commandForms.Length; i++)
			{
				string iDString = commandForms[i].IDString;
				if (commandForms[i].PostStringMode)
				{
					if (commandString.IndexOf(iDString) == 0)
					{
						postString = commandString.Substring(iDString.Length);
						return i;
					}
				}
				else if (commandString == iDString)
				{
					postString = "";
					return i;
				}
			}
			postString = "";
			return -1;
		}

		private static bool ParseSubCharsCommand(int numForms, CommandSubCharsSet[] forms, string commandString, ArrayList indices)
		{
			indices.Clear();
			int num = 0;
			for (int i = 0; i < numForms; i++)
			{
				CommandSubCharsSet commandSubCharsSet = forms[i];
				int num2 = -1;
				int length = commandSubCharsSet.Chars.Length;
				for (int j = 0; j < length; j++)
				{
					char value = commandSubCharsSet.Chars[j];
					int num3 = commandString.IndexOf(value);
					if (num3 >= 0)
					{
						if (num2 >= 0)
						{
							return false;
						}
						if (commandString.IndexOf(value, num3 + 1) >= 0)
						{
							return false;
						}
						num2 = j;
						num++;
					}
				}
				if (num2 == -1 && !commandSubCharsSet.EmptyAllowed)
				{
					return false;
				}
				indices.Add(num2);
			}
			return num == commandString.Length;
		}

		private static bool IsItSwitchChar(char c)
		{
			return c == '-' || c == '/';
		}
	}
	public class CommandForm
	{
		public string IDString = "";

		public bool PostStringMode = false;

		public CommandForm(string idString, bool postStringMode)
		{
			IDString = idString;
			PostStringMode = postStringMode;
		}
	}
	internal class CommandSubCharsSet
	{
		public string Chars = "";

		public bool EmptyAllowed = false;
	}
}
namespace LZ4ps
{
	public static class LZ4Codec
	{
		private class LZ4HC_Data_Structure
		{
			public byte[] src;

			public int src_base;

			public int src_end;

			public int src_LASTLITERALS;

			public byte[] dst;

			public int dst_base;

			public int dst_len;

			public int dst_end;

			public int[] hashTable;

			public ushort[] chainTable;

			public int nextToUpdate;
		}

		private const int MEMORY_USAGE = 14;

		private const int NOTCOMPRESSIBLE_DETECTIONLEVEL = 6;

		private const int BLOCK_COPY_LIMIT = 16;

		private const int MINMATCH = 4;

		private const int SKIPSTRENGTH = 6;

		private const int COPYLENGTH = 8;

		private const int LASTLITERALS = 5;

		private const int MFLIMIT = 12;

		private const int MINLENGTH = 13;

		private const int MAXD_LOG = 16;

		private const int MAXD = 65536;

		private const int MAXD_MASK = 65535;

		private const int MAX_DISTANCE = 65535;

		private const int ML_BITS = 4;

		private const int ML_MASK = 15;

		private const int RUN_BITS = 4;

		private const int RUN_MASK = 15;

		private const int STEPSIZE_64 = 8;

		private const int STEPSIZE_32 = 4;

		private const int LZ4_64KLIMIT = 65547;

		private const int HASH_LOG = 12;

		private const int HASH_TABLESIZE = 4096;

		private const int HASH_ADJUST = 20;

		private const int HASH64K_LOG = 13;

		private const int HASH64K_TABLESIZE = 8192;

		private const int HASH64K_ADJUST = 19;

		private const int HASHHC_LOG = 15;

		private const int HASHHC_TABLESIZE = 32768;

		private const int HASHHC_ADJUST = 17;

		private static readonly int[] DECODER_TABLE_32 = new int[8] { 0, 3, 2, 3, 0, 0, 0, 0 };

		private static readonly int[] DECODER_TABLE_64 = new int[8] { 0, 0, 0, -1, 0, 1, 2, 3 };

		private static readonly int[] DEBRUIJN_TABLE_32 = new int[32]
		{
			0, 0, 3, 0, 3, 1, 3, 0, 3, 2,
			2, 1, 3, 2, 0, 1, 3, 3, 1, 2,
			2, 2, 2, 0, 3, 1, 2, 0, 1, 0,
			1, 1
		};

		private static readonly int[] DEBRUIJN_TABLE_64 = new int[64]
		{
			0, 0, 0, 0, 0, 1, 1, 2, 0, 3,
			1, 3, 1, 4, 2, 7, 0, 2, 3, 6,
			1, 5, 3, 5, 1, 3, 4, 4, 2, 5,
			6, 7, 7, 0, 1, 2, 3, 3, 4, 6,
			2, 6, 5, 5, 3, 4, 5, 6, 7, 1,
			2, 4, 6, 4, 4, 5, 7, 2, 6, 5,
			7, 6, 7, 7
		};

		private const int MAX_NB_ATTEMPTS = 256;

		private const int OPTIMAL_ML = 18;

		public static int MaximumOutputLength(int inputLength)
		{
			return inputLength + inputLength / 255 + 16;
		}

		internal static void CheckArguments(byte[] input, int inputOffset, ref int inputLength, byte[] output, int outputOffset, ref int outputLength)
		{
			if (inputLength < 0)
			{
				inputLength = input.Length - inputOffset;
			}
			if (inputLength == 0)
			{
				outputLength = 0;
				return;
			}
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (inputOffset < 0 || inputOffset + inputLength > input.Length)
			{
				throw new ArgumentException("inputOffset and inputLength are invalid for given input");
			}
			if (outputLength < 0)
			{
				outputLength = output.Length - outputOffset;
			}
			if (output == null)
			{
				throw new ArgumentNullException("output");
			}
			if (outputOffset >= 0 && outputOffset + outputLength <= output.Length)
			{
				return;
			}
			throw new ArgumentException("outputOffset and outputLength are invalid for given output");
		}

		[Conditional("DEBUG")]
		private static void Assert(bool condition, string errorMessage)
		{
			if (!condition)
			{
				throw new ArgumentException(errorMessage);
			}
			Debug.Assert(condition, errorMessage);
		}

		internal static void Poke2(byte[] buffer, int offset, ushort value)
		{
			buffer[offset] = (byte)value;
			buffer[offset + 1] = (byte)(value >> 8);
		}

		internal static ushort Peek2(byte[] buffer, int offset)
		{
			return (ushort)(buffer[offset] | (buffer[offset + 1] << 8));
		}

		internal static uint Peek4(byte[] buffer, int offset)
		{
			return (uint)(buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24));
		}

		private static uint Xor4(byte[] buffer, int offset1, int offset2)
		{
			uint num = (uint)(buffer[offset1] | (buffer[offset1 + 1] << 8) | (buffer[offset1 + 2] << 16) | (buffer[offset1 + 3] << 24));
			uint num2 = (uint)(buffer[offset2] | (buffer[offset2 + 1] << 8) | (buffer[offset2 + 2] << 16) | (buffer[offset2 + 3] << 24));
			return num ^ num2;
		}

		private static ulong Xor8(byte[] buffer, int offset1, int offset2)
		{
			ulong num = buffer[offset1] | ((ulong)buffer[offset1 + 1] << 8) | ((ulong)buffer[offset1 + 2] << 16) | ((ulong)buffer[offset1 + 3] << 24) | ((ulong)buffer[offset1 + 4] << 32) | ((ulong)buffer[offset1 + 5] << 40) | ((ulong)buffer[offset1 + 6] << 48) | ((ulong)buffer[offset1 + 7] << 56);
			ulong num2 = buffer[offset2] | ((ulong)buffer[offset2 + 1] << 8) | ((ulong)buffer[offset2 + 2] << 16) | ((ulong)buffer[offset2 + 3] << 24) | ((ulong)buffer[offset2 + 4] << 32) | ((ulong)buffer[offset2 + 5] << 40) | ((ulong)buffer[offset2 + 6] << 48) | ((ulong)buffer[offset2 + 7] << 56);
			return num ^ num2;
		}

		private static bool Equal2(byte[] buffer, int offset1, int offset2)
		{
			if (buffer[offset1] != buffer[offset2])
			{
				return false;
			}
			return buffer[offset1 + 1] == buffer[offset2 + 1];
		}

		private static bool Equal4(byte[] buffer, int offset1, int offset2)
		{
			if (buffer[offset1] != buffer[offset2])
			{
				return false;
			}
			if (buffer[offset1 + 1] != buffer[offset2 + 1])
			{
				return false;
			}
			if (buffer[offset1 + 2] != buffer[offset2 + 2])
			{
				return false;
			}
			return buffer[offset1 + 3] == buffer[offset2 + 3];
		}

		private static void Copy4(byte[] buf, int src, int dst)
		{
			Assert(dst > src, "Copying backwards is not implemented");
			buf[dst + 3] = buf[src + 3];
			buf[dst + 2] = buf[src + 2];
			buf[dst + 1] = buf[src + 1];
			buf[dst] = buf[src];
		}

		private static void Copy8(byte[] buf, int src, int dst)
		{
			Assert(dst > src, "Copying backwards is not implemented");
			buf[dst + 7] = buf[src + 7];
			buf[dst + 6] = buf[src + 6];
			buf[dst + 5] = buf[src + 5];
			buf[dst + 4] = buf[src + 4];
			buf[dst + 3] = buf[src + 3];
			buf[dst + 2] = buf[src + 2];
			buf[dst + 1] = buf[src + 1];
			buf[dst] = buf[src];
		}

		private static void BlockCopy(byte[] src, int src_0, byte[] dst, int dst_0, int len)
		{
			Assert(src != dst, "BlockCopy does not handle copying to the same buffer");
			if (len >= 16)
			{
				Buffer.BlockCopy(src, src_0, dst, dst_0, len);
				return;
			}
			while (len >= 8)
			{
				dst[dst_0] = src[src_0];
				dst[dst_0 + 1] = src[src_0 + 1];
				dst[dst_0 + 2] = src[src_0 + 2];
				dst[dst_0 + 3] = src[src_0 + 3];
				dst[dst_0 + 4] = src[src_0 + 4];
				dst[dst_0 + 5] = src[src_0 + 5];
				dst[dst_0 + 6] = src[src_0 + 6];
				dst[dst_0 + 7] = src[src_0 + 7];
				len -= 8;
				src_0 += 8;
				dst_0 += 8;
			}
			while (len >= 4)
			{
				dst[dst_0] = src[src_0];
				dst[dst_0 + 1] = src[src_0 + 1];
				dst[dst_0 + 2] = src[src_0 + 2];
				dst[dst_0 + 3] = src[src_0 + 3];
				len -= 4;
				src_0 += 4;
				dst_0 += 4;
			}
			while (len-- > 0)
			{
				dst[dst_0++] = src[src_0++];
			}
		}

		private static int WildCopy(byte[] src, int src_0, byte[] dst, int dst_0, int dst_end)
		{
			int num = dst_end - dst_0;
			Assert(src != dst, "BlockCopy does not handle copying to the same buffer");
			Assert(num > 0, "Length have to be greater than 0");
			if (num >= 16)
			{
				Buffer.BlockCopy(src, src_0, dst, dst_0, num);
			}
			else
			{
				while (num >= 4)
				{
					dst[dst_0] = src[src_0];
					dst[dst_0 + 1] = src[src_0 + 1];
					dst[dst_0 + 2] = src[src_0 + 2];
					dst[dst_0 + 3] = src[src_0 + 3];
					num -= 4;
					src_0 += 4;
					dst_0 += 4;
				}
				while (num-- > 0)
				{
					dst[dst_0++] = src[src_0++];
				}
			}
			return num;
		}

		private static int SecureCopy(byte[] buffer, int src, int dst, int dst_end)
		{
			int num = dst - src;
			int num2 = dst_end - dst;
			int num3 = num2;
			Assert(num >= 4, "Target must be at least 4 bytes further than source");
			Assert(condition: true, "This method requires BLOCK_COPY_LIMIT > 4");
			Assert(num3 > 0, "Length have to be greater than 0");
			if (num >= 16)
			{
				if (num >= num2)
				{
					Buffer.BlockCopy(buffer, src, buffer, dst, num2);
					return num2;
				}
				do
				{
					Buffer.BlockCopy(buffer, src, buffer, dst, num);
					src += num;
					dst += num;
					num3 -= num;
				}
				while (num3 >= num);
			}
			while (num3 >= 4)
			{
				buffer[dst] = buffer[src];
				buffer[dst + 1] = buffer[src + 1];
				buffer[dst + 2] = buffer[src + 2];
				buffer[dst + 3] = buffer[src + 3];
				dst += 4;
				src += 4;
				num3 -= 4;
			}
			while (num3-- > 0)
			{
				buffer[dst++] = buffer[src++];
			}
			return num2;
		}

		public static int Encode32(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			if (outputLength == 0)
			{
				return 0;
			}
			if (inputLength < 65547)
			{
				ushort[] hash_table = new ushort[8192];
				return LZ4_compress64kCtx_safe32(hash_table, input, output, inputOffset, outputOffset, inputLength, outputLength);
			}
			int[] hash_table2 = new int[4096];
			return LZ4_compressCtx_safe32(hash_table2, input, output, inputOffset, outputOffset, inputLength, outputLength);
		}

		public static byte[] Encode32(byte[] input, int inputOffset, int inputLength)
		{
			if (inputLength < 0)
			{
				inputLength = input.Length - inputOffset;
			}
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (inputOffset < 0 || inputOffset + inputLength > input.Length)
			{
				throw new ArgumentException("inputOffset and inputLength are invalid for given input");
			}
			byte[] array = new byte[MaximumOutputLength(inputLength)];
			int num = Encode32(input, inputOffset, inputLength, array, 0, array.Length);
			if (num != array.Length)
			{
				if (num < 0)
				{
					throw new InvalidOperationException("Compression has been corrupted");
				}
				byte[] array2 = new byte[num];
				Buffer.BlockCopy(array, 0, array2, 0, num);
				return array2;
			}
			return array;
		}

		public static int Encode64(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			if (outputLength == 0)
			{
				return 0;
			}
			if (inputLength < 65547)
			{
				ushort[] hash_table = new ushort[8192];
				return LZ4_compress64kCtx_safe64(hash_table, input, output, inputOffset, outputOffset, inputLength, outputLength);
			}
			int[] hash_table2 = new int[4096];
			return LZ4_compressCtx_safe64(hash_table2, input, output, inputOffset, outputOffset, inputLength, outputLength);
		}

		public static byte[] Encode64(byte[] input, int inputOffset, int inputLength)
		{
			if (inputLength < 0)
			{
				inputLength = input.Length - inputOffset;
			}
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (inputOffset < 0 || inputOffset + inputLength > input.Length)
			{
				throw new ArgumentException("inputOffset and inputLength are invalid for given input");
			}
			byte[] array = new byte[MaximumOutputLength(inputLength)];
			int num = Encode64(input, inputOffset, inputLength, array, 0, array.Length);
			if (num != array.Length)
			{
				if (num < 0)
				{
					throw new InvalidOperationException("Compression has been corrupted");
				}
				byte[] array2 = new byte[num];
				Buffer.BlockCopy(array, 0, array2, 0, num);
				return array2;
			}
			return array;
		}

		public static int Decode32(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength, bool knownOutputLength)
		{
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			if (outputLength == 0)
			{
				return 0;
			}
			if (knownOutputLength)
			{
				int num = LZ4_uncompress_safe32(input, output, inputOffset, outputOffset, outputLength);
				if (num != inputLength)
				{
					throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given.");
				}
				return outputLength;
			}
			int num2 = LZ4_uncompress_unknownOutputSize_safe32(input, output, inputOffset, outputOffset, inputLength, outputLength);
			if (num2 < 0)
			{
				throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given.");
			}
			return num2;
		}

		public static byte[] Decode32(byte[] input, int inputOffset, int inputLength, int outputLength)
		{
			if (inputLength < 0)
			{
				inputLength = input.Length - inputOffset;
			}
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (inputOffset < 0 || inputOffset + inputLength > input.Length)
			{
				throw new ArgumentException("inputOffset and inputLength are invalid for given input");
			}
			byte[] array = new byte[outputLength];
			int num = Decode32(input, inputOffset, inputLength, array, 0, outputLength, knownOutputLength: true);
			if (num != outputLength)
			{
				throw new ArgumentException("outputLength is not valid");
			}
			return array;
		}

		public static int Decode64(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength, bool knownOutputLength)
		{
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			if (outputLength == 0)
			{
				return 0;
			}
			if (knownOutputLength)
			{
				int num = LZ4_uncompress_safe64(input, output, inputOffset, outputOffset, outputLength);
				if (num != inputLength)
				{
					throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given.");
				}
				return outputLength;
			}
			int num2 = LZ4_uncompress_unknownOutputSize_safe64(input, output, inputOffset, outputOffset, inputLength, outputLength);
			if (num2 < 0)
			{
				throw new ArgumentException("LZ4 block is corrupted, or invalid length has been given.");
			}
			return num2;
		}

		public static byte[] Decode64(byte[] input, int inputOffset, int inputLength, int outputLength)
		{
			if (inputLength < 0)
			{
				inputLength = input.Length - inputOffset;
			}
			if (input == null)
			{
				throw new ArgumentNullException("input");
			}
			if (inputOffset < 0 || inputOffset + inputLength > input.Length)
			{
				throw new ArgumentException("inputOffset and inputLength are invalid for given input");
			}
			byte[] array = new byte[outputLength];
			int num = Decode64(input, inputOffset, inputLength, array, 0, outputLength, knownOutputLength: true);
			if (num != outputLength)
			{
				throw new ArgumentException("outputLength is not valid");
			}
			return array;
		}

		private static LZ4HC_Data_Structure LZ4HC_Create(byte[] src, int src_0, int src_len, byte[] dst, int dst_0, int dst_len)
		{
			LZ4HC_Data_Structure lZ4HC_Data_Structure = new LZ4HC_Data_Structure();
			lZ4HC_Data_Structure.src = src;
			lZ4HC_Data_Structure.src_base = src_0;
			lZ4HC_Data_Structure.src_end = src_0 + src_len;
			lZ4HC_Data_Structure.src_LASTLITERALS = src_0 + src_len - 5;
			lZ4HC_Data_Structure.dst = dst;
			lZ4HC_Data_Structure.dst_base = dst_0;
			lZ4HC_Data_Structure.dst_len = dst_len;
			lZ4HC_Data_Structure.dst_end = dst_0 + dst_len;
			lZ4HC_Data_Structure.hashTable = new int[32768];
			lZ4HC_Data_Structure.chainTable = new ushort[65536];
			lZ4HC_Data_Structure.nextToUpdate = src_0 + 1;
			LZ4HC_Data_Structure lZ4HC_Data_Structure2 = lZ4HC_Data_Structure;
			ushort[] chainTable = lZ4HC_Data_Structure2.chainTable;
			for (int num = chainTable.Length - 1; num >= 0; num--)
			{
				chainTable[num] = ushort.MaxValue;
			}
			return lZ4HC_Data_Structure2;
		}

		private static int LZ4_compressHC_32(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			return LZ4_compressHCCtx_32(LZ4HC_Create(input, inputOffset, inputLength, output, outputOffset, outputLength));
		}

		public static int Encode32HC(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			if (inputLength == 0)
			{
				return 0;
			}
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			int num = LZ4_compressHC_32(input, inputOffset, inputLength, output, outputOffset, outputLength);
			return (num <= 0) ? (-1) : num;
		}

		public static byte[] Encode32HC(byte[] input, int inputOffset, int inputLength)
		{
			if (inputLength == 0)
			{
				return new byte[0];
			}
			int num = MaximumOutputLength(inputLength);
			byte[] array = new byte[num];
			int num2 = Encode32HC(input, inputOffset, inputLength, array, 0, num);
			if (num2 < 0)
			{
				throw new ArgumentException("Provided data seems to be corrupted.");
			}
			if (num2 != num)
			{
				byte[] array2 = new byte[num2];
				Buffer.BlockCopy(array, 0, array2, 0, num2);
				array = array2;
			}
			return array;
		}

		private static int LZ4_compressHC_64(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			return LZ4_compressHCCtx_64(LZ4HC_Create(input, inputOffset, inputLength, output, outputOffset, outputLength));
		}

		public static int Encode64HC(byte[] input, int inputOffset, int inputLength, byte[] output, int outputOffset, int outputLength)
		{
			if (inputLength == 0)
			{
				return 0;
			}
			CheckArguments(input, inputOffset, ref inputLength, output, outputOffset, ref outputLength);
			int num = LZ4_compressHC_64(input, inputOffset, inputLength, output, outputOffset, outputLength);
			return (num <= 0) ? (-1) : num;
		}

		public static byte[] Encode64HC(byte[] input, int inputOffset, int inputLength)
		{
			if (inputLength == 0)
			{
				return new byte[0];
			}
			int num = MaximumOutputLength(inputLength);
			byte[] array = new byte[num];
			int num2 = Encode64HC(input, inputOffset, inputLength, array, 0, num);
			if (num2 < 0)
			{
				throw new ArgumentException("Provided data seems to be corrupted.");
			}
			if (num2 != num)
			{
				byte[] array2 = new byte[num2];
				Buffer.BlockCopy(array, 0, array2, 0, num2);
				array = array2;
			}
			return array;
		}

		private static int LZ4_compressCtx_safe32(int[] hash_table, byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_32;
			int num = src_0;
			int num2 = num;
			int num3 = num + src_len;
			int num4 = num3 - 12;
			int num5 = dst_0;
			int num6 = num5 + dst_maxlen;
			int num7 = num3 - 5;
			int num8 = num7 - 1;
			int num9 = num7 - 3;
			int num10 = num6 - 6;
			int num11 = num6 - 8;
			if (src_len >= 13)
			{
				hash_table[(int)Peek4(src, num) * -1640531535 >>> 20] = num - src_0;
				num++;
				uint num12 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
				while (true)
				{
					int num13 = 67;
					int num14 = num;
					int num17;
					while (true)
					{
						uint num15 = num12;
						int num16 = num13++ >> 6;
						num = num14;
						num14 = num + num16;
						if (num14 > num4)
						{
							break;
						}
						num12 = (uint)((int)Peek4(src, num14) * -1640531535) >> 20;
						num17 = src_0 + hash_table[num15];
						hash_table[num15] = num - src_0;
						if (num17 < num - 65535 || !Equal4(src, num17, num))
						{
							continue;
						}
						goto IL_0108;
					}
					break;
					IL_03fe:
					num2 = num++;
					num12 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
					continue;
					IL_0108:
					while (num > num2 && num17 > src_0 && src[num - 1] == src[num17 - 1])
					{
						num--;
						num17--;
					}
					int num18 = num - num2;
					int num19 = num5++;
					if (num5 + num18 + (num18 >> 8) > num11)
					{
						return 0;
					}
					if (num18 >= 15)
					{
						int num20 = num18 - 15;
						dst[num19] = 240;
						if (num20 > 254)
						{
							do
							{
								dst[num5++] = byte.MaxValue;
								num20 -= 255;
							}
							while (num20 > 254);
							dst[num5++] = (byte)num20;
							BlockCopy(src, num2, dst, num5, num18);
							num5 += num18;
							goto IL_020c;
						}
						dst[num5++] = (byte)num20;
					}
					else
					{
						dst[num19] = (byte)(num18 << 4);
					}
					if (num18 > 0)
					{
						int num21 = num5 + num18;
						WildCopy(src, num2, dst, num5, num21);
						num5 = num21;
					}
					goto IL_020c;
					IL_020c:
					while (true)
					{
						Poke2(dst, num5, (ushort)(num - num17));
						num5 += 2;
						num += 4;
						num17 += 4;
						num2 = num;
						while (true)
						{
							if (num < num9)
							{
								int num22 = (int)Xor4(src, num17, num);
								if (num22 == 0)
								{
									num += 4;
									num17 += 4;
									continue;
								}
								num += dEBRUIJN_TABLE_[(num22 & -num22) * 125613361 >>> 27];
								break;
							}
							if (num < num8 && Equal2(src, num17, num))
							{
								num += 2;
								num17 += 2;
							}
							if (num < num7 && src[num17] == src[num])
							{
								num++;
							}
							break;
						}
						num18 = num - num2;
						if (num5 + (num18 >> 8) > num10)
						{
							return 0;
						}
						if (num18 >= 15)
						{
							dst[num19] += 15;
							for (num18 -= 15; num18 > 509; num18 -= 510)
							{
								dst[num5++] = byte.MaxValue;
								dst[num5++] = byte.MaxValue;
							}
							if (num18 > 254)
							{
								num18 -= 255;
								dst[num5++] = byte.MaxValue;
							}
							dst[num5++] = (byte)num18;
						}
						else
						{
							dst[num19] += (byte)num18;
						}
						if (num > num4)
						{
							break;
						}
						hash_table[(int)Peek4(src, num - 2) * -1640531535 >>> 20] = num - 2 - src_0;
						uint num15 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
						num17 = src_0 + hash_table[num15];
						hash_table[num15] = num - src_0;
						if (num17 > num - 65536 && Equal4(src, num17, num))
						{
							num19 = num5++;
							dst[num19] = 0;
							continue;
						}
						goto IL_03fe;
					}
					num2 = num;
					break;
				}
			}
			int num23 = num3 - num2;
			if (num5 + num23 + 1 + (num23 + 255 - 15) / 255 > num6)
			{
				return 0;
			}
			if (num23 >= 15)
			{
				dst[num5++] = 240;
				for (num23 -= 15; num23 > 254; num23 -= 255)
				{
					dst[num5++] = byte.MaxValue;
				}
				dst[num5++] = (byte)num23;
			}
			else
			{
				dst[num5++] = (byte)(num23 << 4);
			}
			BlockCopy(src, num2, dst, num5, num3 - num2);
			num5 += num3 - num2;
			return num5 - dst_0;
		}

		private static int LZ4_compress64kCtx_safe32(ushort[] hash_table, byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_32;
			int num = src_0;
			int num2 = num;
			int num3 = num;
			int num4 = num + src_len;
			int num5 = num4 - 12;
			int num6 = dst_0;
			int num7 = num6 + dst_maxlen;
			int num8 = num4 - 5;
			int num9 = num8 - 1;
			int num10 = num8 - 3;
			int num11 = num7 - 6;
			int num12 = num7 - 8;
			if (src_len >= 13)
			{
				num++;
				uint num13 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
				while (true)
				{
					int num14 = 67;
					int num15 = num;
					int num18;
					while (true)
					{
						uint num16 = num13;
						int num17 = num14++ >> 6;
						num = num15;
						num15 = num + num17;
						if (num15 > num5)
						{
							break;
						}
						num13 = (uint)((int)Peek4(src, num15) * -1640531535) >> 19;
						num18 = num3 + hash_table[num16];
						hash_table[num16] = (ushort)(num - num3);
						if (!Equal4(src, num18, num))
						{
							continue;
						}
						goto IL_00e8;
					}
					break;
					IL_03d0:
					num2 = num++;
					num13 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
					continue;
					IL_00e8:
					while (num > num2 && num18 > src_0 && src[num - 1] == src[num18 - 1])
					{
						num--;
						num18--;
					}
					int num19 = num - num2;
					int num20 = num6++;
					if (num6 + num19 + (num19 >> 8) > num12)
					{
						return 0;
					}
					if (num19 >= 15)
					{
						int num21 = num19 - 15;
						dst[num20] = 240;
						if (num21 > 254)
						{
							do
							{
								dst[num6++] = byte.MaxValue;
								num21 -= 255;
							}
							while (num21 > 254);
							dst[num6++] = (byte)num21;
							BlockCopy(src, num2, dst, num6, num19);
							num6 += num19;
							goto IL_01ea;
						}
						dst[num6++] = (byte)num21;
					}
					else
					{
						dst[num20] = (byte)(num19 << 4);
					}
					if (num19 > 0)
					{
						int num22 = num6 + num19;
						WildCopy(src, num2, dst, num6, num22);
						num6 = num22;
					}
					goto IL_01ea;
					IL_01ea:
					while (true)
					{
						Poke2(dst, num6, (ushort)(num - num18));
						num6 += 2;
						num += 4;
						num18 += 4;
						num2 = num;
						while (true)
						{
							if (num < num10)
							{
								int num23 = (int)Xor4(src, num18, num);
								if (num23 == 0)
								{
									num += 4;
									num18 += 4;
									continue;
								}
								num += dEBRUIJN_TABLE_[(num23 & -num23) * 125613361 >>> 27];
								break;
							}
							if (num < num9 && Equal2(src, num18, num))
							{
								num += 2;
								num18 += 2;
							}
							if (num < num8 && src[num18] == src[num])
							{
								num++;
							}
							break;
						}
						int num21 = num - num2;
						if (num6 + (num21 >> 8) > num11)
						{
							return 0;
						}
						if (num21 >= 15)
						{
							dst[num20] += 15;
							for (num21 -= 15; num21 > 509; num21 -= 510)
							{
								dst[num6++] = byte.MaxValue;
								dst[num6++] = byte.MaxValue;
							}
							if (num21 > 254)
							{
								num21 -= 255;
								dst[num6++] = byte.MaxValue;
							}
							dst[num6++] = (byte)num21;
						}
						else
						{
							dst[num20] += (byte)num21;
						}
						if (num > num5)
						{
							break;
						}
						hash_table[(int)Peek4(src, num - 2) * -1640531535 >>> 19] = (ushort)(num - 2 - num3);
						uint num16 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
						num18 = num3 + hash_table[num16];
						hash_table[num16] = (ushort)(num - num3);
						if (Equal4(src, num18, num))
						{
							num20 = num6++;
							dst[num20] = 0;
							continue;
						}
						goto IL_03d0;
					}
					num2 = num;
					break;
				}
			}
			int num24 = num4 - num2;
			if (num6 + num24 + 1 + (num24 - 15 + 255) / 255 > num7)
			{
				return 0;
			}
			if (num24 >= 15)
			{
				dst[num6++] = 240;
				for (num24 -= 15; num24 > 254; num24 -= 255)
				{
					dst[num6++] = byte.MaxValue;
				}
				dst[num6++] = (byte)num24;
			}
			else
			{
				dst[num6++] = (byte)(num24 << 4);
			}
			BlockCopy(src, num2, dst, num6, num4 - num2);
			num6 += num4 - num2;
			return num6 - dst_0;
		}

		private static int LZ4_uncompress_safe32(byte[] src, byte[] dst, int src_0, int dst_0, int dst_len)
		{
			int[] dECODER_TABLE_ = DECODER_TABLE_32;
			int num = src_0;
			int num2 = dst_0;
			int num3 = num2 + dst_len;
			int num4 = num3 - 5;
			int num5 = num3 - 8;
			int num6 = num3 - 8;
			while (true)
			{
				byte b = src[num++];
				int num7;
				if ((num7 = b >> 4) == 15)
				{
					int num8;
					while ((num8 = src[num++]) == 255)
					{
						num7 += 255;
					}
					num7 += num8;
				}
				int num9 = num2 + num7;
				if (num9 > num5)
				{
					if (num9 != num3)
					{
						break;
					}
					BlockCopy(src, num, dst, num2, num7);
					num += num7;
					return num - src_0;
				}
				if (num2 < num9)
				{
					int num10 = WildCopy(src, num, dst, num2, num9);
					num += num10;
					num2 += num10;
				}
				num -= num2 - num9;
				num2 = num9;
				int num11 = num9 - Peek2(src, num);
				num += 2;
				if (num11 < dst_0)
				{
					break;
				}
				if ((num7 = b & 0xF) == 15)
				{
					while (src[num] == byte.MaxValue)
					{
						num++;
						num7 += 255;
					}
					num7 += src[num++];
				}
				if (num2 - num11 < 4)
				{
					dst[num2] = dst[num11];
					dst[num2 + 1] = dst[num11 + 1];
					dst[num2 + 2] = dst[num11 + 2];
					dst[num2 + 3] = dst[num11 + 3];
					num2 += 4;
					num11 += 4;
					num11 -= dECODER_TABLE_[num2 - num11];
					Copy4(dst, num11, num2);
					num2 = num2;
					num11 = num11;
				}
				else
				{
					Copy4(dst, num11, num2);
					num2 += 4;
					num11 += 4;
				}
				num9 = num2 + num7;
				if (num9 > num6)
				{
					if (num9 > num4)
					{
						break;
					}
					if (num2 < num5)
					{
						int num10 = SecureCopy(dst, num11, num2, num5);
						num11 += num10;
						num2 += num10;
					}
					while (num2 < num9)
					{
						dst[num2++] = dst[num11++];
					}
					num2 = num9;
				}
				else
				{
					if (num2 < num9)
					{
						SecureCopy(dst, num11, num2, num9);
					}
					num2 = num9;
				}
			}
			return -(num - src_0);
		}

		private static int LZ4_uncompress_unknownOutputSize_safe32(byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dECODER_TABLE_ = DECODER_TABLE_32;
			int num = src_0;
			int num2 = num + src_len;
			int num3 = dst_0;
			int num4 = num3 + dst_maxlen;
			int num5 = num2 - 8;
			int num6 = num2 - 6;
			int num7 = num4 - 8;
			int num8 = num4 - 8;
			int num9 = num4 - 5;
			int num10 = num4 - 12;
			if (num != num2)
			{
				while (true)
				{
					byte b = src[num++];
					int num11;
					if ((num11 = b >> 4) == 15)
					{
						int num12 = 255;
						while (num < num2 && num12 == 255)
						{
							num11 += (num12 = src[num++]);
						}
					}
					int num13 = num3 + num11;
					if (num13 > num10 || num + num11 > num5)
					{
						if (num13 > num4 || num + num11 != num2)
						{
							break;
						}
						BlockCopy(src, num, dst, num3, num11);
						num3 += num11;
						return num3 - dst_0;
					}
					if (num3 < num13)
					{
						int num14 = WildCopy(src, num, dst, num3, num13);
						num += num14;
						num3 += num14;
					}
					num -= num3 - num13;
					num3 = num13;
					int num15 = num13 - Peek2(src, num);
					num += 2;
					if (num15 < dst_0)
					{
						break;
					}
					if ((num11 = b & 0xF) == 15)
					{
						while (num < num6)
						{
							int num16 = src[num++];
							num11 += num16;
							if (num16 == 255)
							{
								continue;
							}
							break;
						}
					}
					if (num3 - num15 < 4)
					{
						dst[num3] = dst[num15];
						dst[num3 + 1] = dst[num15 + 1];
						dst[num3 + 2] = dst[num15 + 2];
						dst[num3 + 3] = dst[num15 + 3];
						num3 += 4;
						num15 += 4;
						num15 -= dECODER_TABLE_[num3 - num15];
						Copy4(dst, num15, num3);
						num3 = num3;
						num15 = num15;
					}
					else
					{
						Copy4(dst, num15, num3);
						num3 += 4;
						num15 += 4;
					}
					num13 = num3 + num11;
					if (num13 > num8)
					{
						if (num13 > num9)
						{
							break;
						}
						if (num3 < num7)
						{
							int num14 = SecureCopy(dst, num15, num3, num7);
							num15 += num14;
							num3 += num14;
						}
						while (num3 < num13)
						{
							dst[num3++] = dst[num15++];
						}
						num3 = num13;
					}
					else
					{
						if (num3 < num13)
						{
							SecureCopy(dst, num15, num3, num13);
						}
						num3 = num13;
					}
				}
			}
			return -(num - src_0);
		}

		private static void LZ4HC_Insert_32(LZ4HC_Data_Structure ctx, int src_p)
		{
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			int i = ctx.nextToUpdate;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			for (; i < src_p; i++)
			{
				int num = i;
				int num2 = num - (hashTable[(int)Peek4(src, num) * -1640531535 >>> 17] + src_base);
				if (num2 > 65535)
				{
					num2 = 65535;
				}
				chainTable[num & 0xFFFF] = (ushort)num2;
				hashTable[(int)Peek4(src, num) * -1640531535 >>> 17] = num - src_base;
			}
			ctx.nextToUpdate = i;
		}

		private static int LZ4HC_CommonLength_32(LZ4HC_Data_Structure ctx, int p1, int p2)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_32;
			byte[] src = ctx.src;
			int src_LASTLITERALS = ctx.src_LASTLITERALS;
			int num = p1;
			while (num < src_LASTLITERALS - 3)
			{
				int num2 = (int)Xor4(src, p2, num);
				if (num2 == 0)
				{
					num += 4;
					p2 += 4;
					continue;
				}
				num += dEBRUIJN_TABLE_[(num2 & -num2) * 125613361 >>> 27];
				return num - p1;
			}
			if (num < src_LASTLITERALS - 1 && Equal2(src, p2, num))
			{
				num += 2;
				p2 += 2;
			}
			if (num < src_LASTLITERALS && src[p2] == src[num])
			{
				num++;
			}
			return num - p1;
		}

		private static int LZ4HC_InsertAndFindBestMatch_32(LZ4HC_Data_Structure ctx, int src_p, ref int src_match)
		{
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int num = 256;
			int num2 = 0;
			int num3 = 0;
			ushort num4 = 0;
			LZ4HC_Insert_32(ctx, src_p);
			int num5 = hashTable[(int)Peek4(src, src_p) * -1640531535 >>> 17] + src_base;
			if (num5 >= src_p - 4)
			{
				if (Equal4(src, num5, src_p))
				{
					num4 = (ushort)(src_p - num5);
					num2 = (num3 = LZ4HC_CommonLength_32(ctx, src_p + 4, num5 + 4) + 4);
					src_match = num5;
				}
				num5 -= chainTable[num5 & 0xFFFF];
			}
			while (num5 >= src_p - 65535 && num != 0)
			{
				num--;
				if (src[num5 + num3] == src[src_p + num3] && Equal4(src, num5, src_p))
				{
					int num6 = LZ4HC_CommonLength_32(ctx, src_p + 4, num5 + 4) + 4;
					if (num6 > num3)
					{
						num3 = num6;
						src_match = num5;
					}
				}
				num5 -= chainTable[num5 & 0xFFFF];
			}
			if (num2 != 0)
			{
				int i = src_p;
				int num7;
				for (num7 = src_p + num2 - 3; i < num7 - num4; i++)
				{
					chainTable[i & 0xFFFF] = num4;
				}
				do
				{
					chainTable[i & 0xFFFF] = num4;
					hashTable[(int)Peek4(src, i) * -1640531535 >>> 17] = i - src_base;
					i++;
				}
				while (i < num7);
				ctx.nextToUpdate = num7;
			}
			return num3;
		}

		private static int LZ4HC_InsertAndGetWiderMatch_32(LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos)
		{
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int src_LASTLITERALS = ctx.src_LASTLITERALS;
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_32;
			int num = 256;
			int num2 = src_p - startLimit;
			LZ4HC_Insert_32(ctx, src_p);
			int num3 = hashTable[(int)Peek4(src, src_p) * -1640531535 >>> 17] + src_base;
			while (num3 >= src_p - 65535 && num != 0)
			{
				num--;
				if (src[startLimit + longest] == src[num3 - num2 + longest] && Equal4(src, num3, src_p))
				{
					int num4 = num3 + 4;
					int num5 = src_p + 4;
					int num6 = src_p;
					while (true)
					{
						if (num5 < src_LASTLITERALS - 3)
						{
							int num7 = (int)Xor4(src, num4, num5);
							if (num7 == 0)
							{
								num5 += 4;
								num4 += 4;
								continue;
							}
							num5 += dEBRUIJN_TABLE_[(num7 & -num7) * 125613361 >>> 27];
							break;
						}
						if (num5 < src_LASTLITERALS - 1 && Equal2(src, num4, num5))
						{
							num5 += 2;
							num4 += 2;
						}
						if (num5 < src_LASTLITERALS && src[num4] == src[num5])
						{
							num5++;
						}
						break;
					}
					num4 = num3;
					while (num6 > startLimit && num4 > src_base && src[num6 - 1] == src[num4 - 1])
					{
						num6--;
						num4--;
					}
					if (num5 - num6 > longest)
					{
						longest = num5 - num6;
						matchpos = num4;
						startpos = num6;
					}
				}
				num3 -= chainTable[num3 & 0xFFFF];
			}
			return longest;
		}

		private static int LZ4_encodeSequence_32(LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref, int dst_end)
		{
			byte[] src = ctx.src;
			byte[] dst = ctx.dst;
			int num = src_p - src_anchor;
			int num2 = dst_p++;
			if (dst_p + num + 8 + (num >> 8) > dst_end)
			{
				return 1;
			}
			int num3;
			if (num >= 15)
			{
				dst[num2] = 240;
				for (num3 = num - 15; num3 > 254; num3 -= 255)
				{
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num3;
			}
			else
			{
				dst[num2] = (byte)(num << 4);
			}
			if (num > 0)
			{
				int num4 = dst_p + num;
				src_anchor += WildCopy(src, src_anchor, dst, dst_p, num4);
				dst_p = num4;
			}
			Poke2(dst, dst_p, (ushort)(src_p - src_ref));
			dst_p += 2;
			num3 = matchLength - 4;
			if (dst_p + 6 + (num3 >> 8) > dst_end)
			{
				return 1;
			}
			if (num3 >= 15)
			{
				dst[num2] += 15;
				for (num3 -= 15; num3 > 509; num3 -= 510)
				{
					dst[dst_p++] = byte.MaxValue;
					dst[dst_p++] = byte.MaxValue;
				}
				if (num3 > 254)
				{
					num3 -= 255;
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num3;
			}
			else
			{
				dst[num2] += (byte)num3;
			}
			src_p += matchLength;
			src_anchor = src_p;
			return 0;
		}

		private static int LZ4_compressHCCtx_32(LZ4HC_Data_Structure ctx)
		{
			byte[] src = ctx.src;
			byte[] dst = ctx.dst;
			int src_base = ctx.src_base;
			int src_end = ctx.src_end;
			int dst_base = ctx.dst_base;
			int dst_len = ctx.dst_len;
			int dst_end = ctx.dst_end;
			int num = src_base;
			int src_anchor = num;
			int num2 = src_end - 12;
			int dst_p = dst_base;
			int src_match = 0;
			int startpos = 0;
			int matchpos = 0;
			int startpos2 = 0;
			int matchpos2 = 0;
			num++;
			while (num < num2)
			{
				int num3 = LZ4HC_InsertAndFindBestMatch_32(ctx, num, ref src_match);
				if (num3 == 0)
				{
					num++;
					continue;
				}
				int num4 = num;
				int num5 = src_match;
				int num6 = num3;
				while (true)
				{
					int num7 = ((num + num3 < num2) ? LZ4HC_InsertAndGetWiderMatch_32(ctx, num + num3 - 2, num + 1, num3, ref matchpos, ref startpos) : num3);
					if (num7 == num3)
					{
						if (LZ4_encodeSequence_32(ctx, ref num, ref dst_p, ref src_anchor, num3, src_match, dst_end) != 0)
						{
							return 0;
						}
						break;
					}
					if (num4 < num && startpos < num + num6)
					{
						num = num4;
						src_match = num5;
						num3 = num6;
					}
					if (startpos - num < 3)
					{
						num3 = num7;
						num = startpos;
						src_match = matchpos;
						continue;
					}
					int num10;
					while (true)
					{
						if (startpos - num < 18)
						{
							int num8 = num3;
							if (num8 > 18)
							{
								num8 = 18;
							}
							if (num + num8 > startpos + num7 - 4)
							{
								num8 = startpos - num + num7 - 4;
							}
							int num9 = num8 - (startpos - num);
							if (num9 > 0)
							{
								startpos += num9;
								matchpos += num9;
								num7 -= num9;
							}
						}
						num10 = ((startpos + num7 < num2) ? LZ4HC_InsertAndGetWiderMatch_32(ctx, startpos + num7 - 3, startpos, num7, ref matchpos2, ref startpos2) : num7);
						if (num10 == num7)
						{
							break;
						}
						if (startpos2 < num + num3 + 3)
						{
							if (startpos2 < num + num3)
							{
								startpos = startpos2;
								matchpos = matchpos2;
								num7 = num10;
								continue;
							}
							goto IL_0269;
						}
						if (startpos < num + num3)
						{
							if (startpos - num < 15)
							{
								if (num3 > 18)
								{
									num3 = 18;
								}
								if (num + num3 > startpos + num7 - 4)
								{
									num3 = startpos - num + num7 - 4;
								}
								int num11 = num3 - (startpos - num);
								if (num11 > 0)
								{
									startpos += num11;
									matchpos += num11;
									num7 -= num11;
								}
							}
							else
							{
								num3 = startpos - num;
							}
						}
						if (LZ4_encodeSequence_32(ctx, ref num, ref dst_p, ref src_anchor, num3, src_match, dst_end) != 0)
						{
							return 0;
						}
						num = startpos;
						src_match = matchpos;
						num3 = num7;
						startpos = startpos2;
						matchpos = matchpos2;
						num7 = num10;
					}
					if (startpos < num + num3)
					{
						num3 = startpos - num;
					}
					if (LZ4_encodeSequence_32(ctx, ref num, ref dst_p, ref src_anchor, num3, src_match, dst_end) != 0)
					{
						return 0;
					}
					num = startpos;
					if (LZ4_encodeSequence_32(ctx, ref num, ref dst_p, ref src_anchor, num7, matchpos, dst_end) != 0)
					{
						return 0;
					}
					break;
					IL_0269:
					if (startpos < num + num3)
					{
						int num12 = num + num3 - startpos;
						startpos += num12;
						matchpos += num12;
						num7 -= num12;
						if (num7 < 4)
						{
							startpos = startpos2;
							matchpos = matchpos2;
							num7 = num10;
						}
					}
					if (LZ4_encodeSequence_32(ctx, ref num, ref dst_p, ref src_anchor, num3, src_match, dst_end) != 0)
					{
						return 0;
					}
					num = startpos2;
					src_match = matchpos2;
					num3 = num10;
					num4 = startpos;
					num5 = matchpos;
					num6 = num7;
				}
			}
			int num13 = src_end - src_anchor;
			if (dst_p - dst_base + num13 + 1 + (num13 + 255 - 15) / 255 > (uint)dst_len)
			{
				return 0;
			}
			if (num13 >= 15)
			{
				dst[dst_p++] = 240;
				for (num13 -= 15; num13 > 254; num13 -= 255)
				{
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num13;
			}
			else
			{
				dst[dst_p++] = (byte)(num13 << 4);
			}
			BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor);
			dst_p += src_end - src_anchor;
			return dst_p - dst_base;
		}

		private static int LZ4_compressCtx_safe64(int[] hash_table, byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_64;
			int num = src_0;
			int num2 = num;
			int num3 = num + src_len;
			int num4 = num3 - 12;
			int num5 = dst_0;
			int num6 = num5 + dst_maxlen;
			int num7 = num3 - 5;
			int num8 = num7 - 1;
			int num9 = num7 - 3;
			int num10 = num7 - 7;
			int num11 = num6 - 6;
			int num12 = num6 - 8;
			if (src_len >= 13)
			{
				hash_table[(int)Peek4(src, num) * -1640531535 >>> 20] = num - src_0;
				num++;
				uint num13 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
				while (true)
				{
					int num14 = 67;
					int num15 = num;
					int num18;
					while (true)
					{
						uint num16 = num13;
						int num17 = num14++ >> 6;
						num = num15;
						num15 = num + num17;
						if (num15 > num4)
						{
							break;
						}
						num13 = (uint)((int)Peek4(src, num15) * -1640531535) >> 20;
						num18 = src_0 + hash_table[num16];
						hash_table[num16] = num - src_0;
						if (num18 < num - 65535 || !Equal4(src, num18, num))
						{
							continue;
						}
						goto IL_010e;
					}
					break;
					IL_042d:
					num2 = num++;
					num13 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
					continue;
					IL_010e:
					while (num > num2 && num18 > src_0 && src[num - 1] == src[num18 - 1])
					{
						num--;
						num18--;
					}
					int num19 = num - num2;
					int num20 = num5++;
					if (num5 + num19 + (num19 >> 8) > num12)
					{
						return 0;
					}
					if (num19 >= 15)
					{
						int num21 = num19 - 15;
						dst[num20] = 240;
						if (num21 > 254)
						{
							do
							{
								dst[num5++] = byte.MaxValue;
								num21 -= 255;
							}
							while (num21 > 254);
							dst[num5++] = (byte)num21;
							BlockCopy(src, num2, dst, num5, num19);
							num5 += num19;
							goto IL_0212;
						}
						dst[num5++] = (byte)num21;
					}
					else
					{
						dst[num20] = (byte)(num19 << 4);
					}
					if (num19 > 0)
					{
						int num22 = num5 + num19;
						WildCopy(src, num2, dst, num5, num22);
						num5 = num22;
					}
					goto IL_0212;
					IL_0212:
					while (true)
					{
						Poke2(dst, num5, (ushort)(num - num18));
						num5 += 2;
						num += 4;
						num18 += 4;
						num2 = num;
						while (true)
						{
							if (num < num10)
							{
								long num23 = (long)Xor8(src, num18, num);
								if (num23 == 0)
								{
									num += 8;
									num18 += 8;
									continue;
								}
								num += dEBRUIJN_TABLE_[(num23 & -num23) * 151050438428048703L >>> 58];
								break;
							}
							if (num < num9 && Equal4(src, num18, num))
							{
								num += 4;
								num18 += 4;
							}
							if (num < num8 && Equal2(src, num18, num))
							{
								num += 2;
								num18 += 2;
							}
							if (num < num7 && src[num18] == src[num])
							{
								num++;
							}
							break;
						}
						num19 = num - num2;
						if (num5 + (num19 >> 8) > num11)
						{
							return 0;
						}
						if (num19 >= 15)
						{
							dst[num20] += 15;
							for (num19 -= 15; num19 > 509; num19 -= 510)
							{
								dst[num5++] = byte.MaxValue;
								dst[num5++] = byte.MaxValue;
							}
							if (num19 > 254)
							{
								num19 -= 255;
								dst[num5++] = byte.MaxValue;
							}
							dst[num5++] = (byte)num19;
						}
						else
						{
							dst[num20] += (byte)num19;
						}
						if (num > num4)
						{
							break;
						}
						hash_table[(int)Peek4(src, num - 2) * -1640531535 >>> 20] = num - 2 - src_0;
						uint num16 = (uint)((int)Peek4(src, num) * -1640531535) >> 20;
						num18 = src_0 + hash_table[num16];
						hash_table[num16] = num - src_0;
						if (num18 > num - 65536 && Equal4(src, num18, num))
						{
							num20 = num5++;
							dst[num20] = 0;
							continue;
						}
						goto IL_042d;
					}
					num2 = num;
					break;
				}
			}
			int num24 = num3 - num2;
			if (num5 + num24 + 1 + (num24 + 255 - 15) / 255 > num6)
			{
				return 0;
			}
			if (num24 >= 15)
			{
				dst[num5++] = 240;
				for (num24 -= 15; num24 > 254; num24 -= 255)
				{
					dst[num5++] = byte.MaxValue;
				}
				dst[num5++] = (byte)num24;
			}
			else
			{
				dst[num5++] = (byte)(num24 << 4);
			}
			BlockCopy(src, num2, dst, num5, num3 - num2);
			num5 += num3 - num2;
			return num5 - dst_0;
		}

		private static int LZ4_compress64kCtx_safe64(ushort[] hash_table, byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_64;
			int num = src_0;
			int num2 = num;
			int num3 = num;
			int num4 = num + src_len;
			int num5 = num4 - 12;
			int num6 = dst_0;
			int num7 = num6 + dst_maxlen;
			int num8 = num4 - 5;
			int num9 = num8 - 1;
			int num10 = num8 - 3;
			int num11 = num8 - 7;
			int num12 = num7 - 6;
			int num13 = num7 - 8;
			if (src_len >= 13)
			{
				num++;
				uint num14 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
				while (true)
				{
					int num15 = 67;
					int num16 = num;
					int num19;
					while (true)
					{
						uint num17 = num14;
						int num18 = num15++ >> 6;
						num = num16;
						num16 = num + num18;
						if (num16 > num5)
						{
							break;
						}
						num14 = (uint)((int)Peek4(src, num16) * -1640531535) >> 19;
						num19 = num3 + hash_table[num17];
						hash_table[num17] = (ushort)(num - num3);
						if (!Equal4(src, num19, num))
						{
							continue;
						}
						goto IL_00ee;
					}
					break;
					IL_03fd:
					num2 = num++;
					num14 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
					continue;
					IL_00ee:
					while (num > num2 && num19 > src_0 && src[num - 1] == src[num19 - 1])
					{
						num--;
						num19--;
					}
					int num20 = num - num2;
					int num21 = num6++;
					if (num6 + num20 + (num20 >> 8) > num13)
					{
						return 0;
					}
					if (num20 >= 15)
					{
						int num22 = num20 - 15;
						dst[num21] = 240;
						if (num22 > 254)
						{
							do
							{
								dst[num6++] = byte.MaxValue;
								num22 -= 255;
							}
							while (num22 > 254);
							dst[num6++] = (byte)num22;
							BlockCopy(src, num2, dst, num6, num20);
							num6 += num20;
							goto IL_01ee;
						}
						dst[num6++] = (byte)num22;
					}
					else
					{
						dst[num21] = (byte)(num20 << 4);
					}
					if (num20 > 0)
					{
						int num23 = num6 + num20;
						WildCopy(src, num2, dst, num6, num23);
						num6 = num23;
					}
					goto IL_01ee;
					IL_01ee:
					while (true)
					{
						Poke2(dst, num6, (ushort)(num - num19));
						num6 += 2;
						num += 4;
						num19 += 4;
						num2 = num;
						while (true)
						{
							if (num < num11)
							{
								long num24 = (long)Xor8(src, num19, num);
								if (num24 == 0)
								{
									num += 8;
									num19 += 8;
									continue;
								}
								num += dEBRUIJN_TABLE_[(num24 & -num24) * 151050438428048703L >>> 58];
								break;
							}
							if (num < num10 && Equal4(src, num19, num))
							{
								num += 4;
								num19 += 4;
							}
							if (num < num9 && Equal2(src, num19, num))
							{
								num += 2;
								num19 += 2;
							}
							if (num < num8 && src[num19] == src[num])
							{
								num++;
							}
							break;
						}
						int num22 = num - num2;
						if (num6 + (num22 >> 8) > num12)
						{
							return 0;
						}
						if (num22 >= 15)
						{
							dst[num21] += 15;
							for (num22 -= 15; num22 > 509; num22 -= 510)
							{
								dst[num6++] = byte.MaxValue;
								dst[num6++] = byte.MaxValue;
							}
							if (num22 > 254)
							{
								num22 -= 255;
								dst[num6++] = byte.MaxValue;
							}
							dst[num6++] = (byte)num22;
						}
						else
						{
							dst[num21] += (byte)num22;
						}
						if (num > num5)
						{
							break;
						}
						hash_table[(int)Peek4(src, num - 2) * -1640531535 >>> 19] = (ushort)(num - 2 - num3);
						uint num17 = (uint)((int)Peek4(src, num) * -1640531535) >> 19;
						num19 = num3 + hash_table[num17];
						hash_table[num17] = (ushort)(num - num3);
						if (Equal4(src, num19, num))
						{
							num21 = num6++;
							dst[num21] = 0;
							continue;
						}
						goto IL_03fd;
					}
					num2 = num;
					break;
				}
			}
			int num25 = num4 - num2;
			if (num6 + num25 + 1 + (num25 - 15 + 255) / 255 > num7)
			{
				return 0;
			}
			if (num25 >= 15)
			{
				dst[num6++] = 240;
				for (num25 -= 15; num25 > 254; num25 -= 255)
				{
					dst[num6++] = byte.MaxValue;
				}
				dst[num6++] = (byte)num25;
			}
			else
			{
				dst[num6++] = (byte)(num25 << 4);
			}
			BlockCopy(src, num2, dst, num6, num4 - num2);
			num6 += num4 - num2;
			return num6 - dst_0;
		}

		private static int LZ4_uncompress_safe64(byte[] src, byte[] dst, int src_0, int dst_0, int dst_len)
		{
			int[] dECODER_TABLE_ = DECODER_TABLE_32;
			int[] dECODER_TABLE_2 = DECODER_TABLE_64;
			int num = src_0;
			int num2 = dst_0;
			int num3 = num2 + dst_len;
			int num4 = num3 - 5;
			int num5 = num3 - 8;
			int num6 = num3 - 8 - 4;
			while (true)
			{
				uint num7 = src[num++];
				int num8;
				if ((num8 = (byte)(num7 >> 4)) == 15)
				{
					int num9;
					while ((num9 = src[num++]) == 255)
					{
						num8 += 255;
					}
					num8 += num9;
				}
				int num10 = num2 + num8;
				if (num10 > num5)
				{
					if (num10 != num3)
					{
						break;
					}
					BlockCopy(src, num, dst, num2, num8);
					num += num8;
					return num - src_0;
				}
				if (num2 < num10)
				{
					int num11 = WildCopy(src, num, dst, num2, num10);
					num += num11;
					num2 += num11;
				}
				num -= num2 - num10;
				num2 = num10;
				int num12 = num10 - Peek2(src, num);
				num += 2;
				if (num12 < dst_0)
				{
					break;
				}
				if ((num8 = (byte)(num7 & 0xF)) == 15)
				{
					while (src[num] == byte.MaxValue)
					{
						num++;
						num8 += 255;
					}
					num8 += src[num++];
				}
				if (num2 - num12 < 8)
				{
					int num13 = dECODER_TABLE_2[num2 - num12];
					dst[num2] = dst[num12];
					dst[num2 + 1] = dst[num12 + 1];
					dst[num2 + 2] = dst[num12 + 2];
					dst[num2 + 3] = dst[num12 + 3];
					num2 += 4;
					num12 += 4;
					num12 -= dECODER_TABLE_[num2 - num12];
					Copy4(dst, num12, num2);
					num2 += 4;
					num12 -= num13;
				}
				else
				{
					Copy8(dst, num12, num2);
					num2 += 8;
					num12 += 8;
				}
				num10 = num2 + num8 - 4;
				if (num10 > num6)
				{
					if (num10 > num4)
					{
						break;
					}
					if (num2 < num5)
					{
						int num11 = SecureCopy(dst, num12, num2, num5);
						num12 += num11;
						num2 += num11;
					}
					while (num2 < num10)
					{
						dst[num2++] = dst[num12++];
					}
					num2 = num10;
				}
				else
				{
					if (num2 < num10)
					{
						SecureCopy(dst, num12, num2, num10);
					}
					num2 = num10;
				}
			}
			return -(num - src_0);
		}

		private static int LZ4_uncompress_unknownOutputSize_safe64(byte[] src, byte[] dst, int src_0, int dst_0, int src_len, int dst_maxlen)
		{
			int[] dECODER_TABLE_ = DECODER_TABLE_32;
			int[] dECODER_TABLE_2 = DECODER_TABLE_64;
			int num = src_0;
			int num2 = num + src_len;
			int num3 = dst_0;
			int num4 = num3 + dst_maxlen;
			int num5 = num2 - 8;
			int num6 = num2 - 6;
			int num7 = num4 - 8;
			int num8 = num4 - 12;
			int num9 = num4 - 5;
			int num10 = num4 - 12;
			if (num != num2)
			{
				while (true)
				{
					byte b = src[num++];
					int num11;
					if ((num11 = b >> 4) == 15)
					{
						int num12 = 255;
						while (num < num2 && num12 == 255)
						{
							num11 += (num12 = src[num++]);
						}
					}
					int num13 = num3 + num11;
					if (num13 > num10 || num + num11 > num5)
					{
						if (num13 > num4 || num + num11 != num2)
						{
							break;
						}
						BlockCopy(src, num, dst, num3, num11);
						num3 += num11;
						return num3 - dst_0;
					}
					if (num3 < num13)
					{
						int num14 = WildCopy(src, num, dst, num3, num13);
						num += num14;
						num3 += num14;
					}
					num -= num3 - num13;
					num3 = num13;
					int num15 = num13 - Peek2(src, num);
					num += 2;
					if (num15 < dst_0)
					{
						break;
					}
					if ((num11 = b & 0xF) == 15)
					{
						while (num < num6)
						{
							int num16 = src[num++];
							num11 += num16;
							if (num16 == 255)
							{
								continue;
							}
							break;
						}
					}
					if (num3 - num15 < 8)
					{
						int num17 = dECODER_TABLE_2[num3 - num15];
						dst[num3] = dst[num15];
						dst[num3 + 1] = dst[num15 + 1];
						dst[num3 + 2] = dst[num15 + 2];
						dst[num3 + 3] = dst[num15 + 3];
						num3 += 4;
						num15 += 4;
						num15 -= dECODER_TABLE_[num3 - num15];
						Copy4(dst, num15, num3);
						num3 += 4;
						num15 -= num17;
					}
					else
					{
						Copy8(dst, num15, num3);
						num3 += 8;
						num15 += 8;
					}
					num13 = num3 + num11 - 4;
					if (num13 > num8)
					{
						if (num13 > num9)
						{
							break;
						}
						if (num3 < num7)
						{
							int num14 = SecureCopy(dst, num15, num3, num7);
							num15 += num14;
							num3 += num14;
						}
						while (num3 < num13)
						{
							dst[num3++] = dst[num15++];
						}
						num3 = num13;
					}
					else
					{
						if (num3 < num13)
						{
							SecureCopy(dst, num15, num3, num13);
						}
						num3 = num13;
					}
				}
			}
			return -(num - src_0);
		}

		private static void LZ4HC_Insert_64(LZ4HC_Data_Structure ctx, int src_p)
		{
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int i;
			for (i = ctx.nextToUpdate; i < src_p; i++)
			{
				int num = i;
				int num2 = num - (hashTable[(int)Peek4(src, num) * -1640531535 >>> 17] + src_base);
				if (num2 > 65535)
				{
					num2 = 65535;
				}
				chainTable[num & 0xFFFF] = (ushort)num2;
				hashTable[(int)Peek4(src, num) * -1640531535 >>> 17] = num - src_base;
			}
			ctx.nextToUpdate = i;
		}

		private static int LZ4HC_CommonLength_64(LZ4HC_Data_Structure ctx, int p1, int p2)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_64;
			byte[] src = ctx.src;
			int src_LASTLITERALS = ctx.src_LASTLITERALS;
			int num = p1;
			while (num < src_LASTLITERALS - 7)
			{
				long num2 = (long)Xor8(src, p2, num);
				if (num2 == 0)
				{
					num += 8;
					p2 += 8;
					continue;
				}
				num += dEBRUIJN_TABLE_[(num2 & -num2) * 151050438428048703L >>> 58];
				return num - p1;
			}
			if (num < src_LASTLITERALS - 3 && Equal4(src, p2, num))
			{
				num += 4;
				p2 += 4;
			}
			if (num < src_LASTLITERALS - 1 && Equal2(src, p2, num))
			{
				num += 2;
				p2 += 2;
			}
			if (num < src_LASTLITERALS && src[p2] == src[num])
			{
				num++;
			}
			return num - p1;
		}

		private static int LZ4HC_InsertAndFindBestMatch_64(LZ4HC_Data_Structure ctx, int src_p, ref int matchpos)
		{
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int num = 256;
			int num2 = 0;
			int num3 = 0;
			ushort num4 = 0;
			LZ4HC_Insert_64(ctx, src_p);
			int num5 = hashTable[(int)Peek4(src, src_p) * -1640531535 >>> 17] + src_base;
			if (num5 >= src_p - 4)
			{
				if (Equal4(src, num5, src_p))
				{
					num4 = (ushort)(src_p - num5);
					num2 = (num3 = LZ4HC_CommonLength_64(ctx, src_p + 4, num5 + 4) + 4);
					matchpos = num5;
				}
				num5 -= chainTable[num5 & 0xFFFF];
			}
			while (num5 >= src_p - 65535 && num != 0)
			{
				num--;
				if (src[num5 + num3] == src[src_p + num3] && Equal4(src, num5, src_p))
				{
					int num6 = LZ4HC_CommonLength_64(ctx, src_p + 4, num5 + 4) + 4;
					if (num6 > num3)
					{
						num3 = num6;
						matchpos = num5;
					}
				}
				num5 -= chainTable[num5 & 0xFFFF];
			}
			if (num2 != 0)
			{
				int i = src_p;
				int num7;
				for (num7 = src_p + num2 - 3; i < num7 - num4; i++)
				{
					chainTable[i & 0xFFFF] = num4;
				}
				do
				{
					chainTable[i & 0xFFFF] = num4;
					hashTable[(int)Peek4(src, i) * -1640531535 >>> 17] = i - src_base;
					i++;
				}
				while (i < num7);
				ctx.nextToUpdate = num7;
			}
			return num3;
		}

		private static int LZ4HC_InsertAndGetWiderMatch_64(LZ4HC_Data_Structure ctx, int src_p, int startLimit, int longest, ref int matchpos, ref int startpos)
		{
			int[] dEBRUIJN_TABLE_ = DEBRUIJN_TABLE_64;
			ushort[] chainTable = ctx.chainTable;
			int[] hashTable = ctx.hashTable;
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int src_LASTLITERALS = ctx.src_LASTLITERALS;
			int num = 256;
			int num2 = src_p - startLimit;
			LZ4HC_Insert_64(ctx, src_p);
			int num3 = hashTable[(int)Peek4(src, src_p) * -1640531535 >>> 17] + src_base;
			while (num3 >= src_p - 65535 && num != 0)
			{
				num--;
				if (src[startLimit + longest] == src[num3 - num2 + longest] && Equal4(src, num3, src_p))
				{
					int num4 = num3 + 4;
					int num5 = src_p + 4;
					int num6 = src_p;
					while (true)
					{
						if (num5 < src_LASTLITERALS - 7)
						{
							long num7 = (long)Xor8(src, num4, num5);
							if (num7 == 0)
							{
								num5 += 8;
								num4 += 8;
								continue;
							}
							num5 += dEBRUIJN_TABLE_[(num7 & -num7) * 151050438428048703L >>> 58];
							break;
						}
						if (num5 < src_LASTLITERALS - 3 && Equal4(src, num4, num5))
						{
							num5 += 4;
							num4 += 4;
						}
						if (num5 < src_LASTLITERALS - 1 && Equal2(src, num4, num5))
						{
							num5 += 2;
							num4 += 2;
						}
						if (num5 < src_LASTLITERALS && src[num4] == src[num5])
						{
							num5++;
						}
						break;
					}
					num4 = num3;
					while (num6 > startLimit && num4 > src_base && src[num6 - 1] == src[num4 - 1])
					{
						num6--;
						num4--;
					}
					if (num5 - num6 > longest)
					{
						longest = num5 - num6;
						matchpos = num4;
						startpos = num6;
					}
				}
				num3 -= chainTable[num3 & 0xFFFF];
			}
			return longest;
		}

		private static int LZ4_encodeSequence_64(LZ4HC_Data_Structure ctx, ref int src_p, ref int dst_p, ref int src_anchor, int matchLength, int src_ref)
		{
			byte[] src = ctx.src;
			byte[] dst = ctx.dst;
			int dst_end = ctx.dst_end;
			int num = src_p - src_anchor;
			int num2 = dst_p++;
			if (dst_p + num + 8 + (num >> 8) > dst_end)
			{
				return 1;
			}
			int num3;
			if (num >= 15)
			{
				dst[num2] = 240;
				for (num3 = num - 15; num3 > 254; num3 -= 255)
				{
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num3;
			}
			else
			{
				dst[num2] = (byte)(num << 4);
			}
			if (num > 0)
			{
				int num4 = dst_p + num;
				src_anchor += WildCopy(src, src_anchor, dst, dst_p, num4);
				dst_p = num4;
			}
			Poke2(dst, dst_p, (ushort)(src_p - src_ref));
			dst_p += 2;
			num3 = matchLength - 4;
			if (dst_p + 6 + (num3 >> 8) > dst_end)
			{
				return 1;
			}
			if (num3 >= 15)
			{
				dst[num2] += 15;
				for (num3 -= 15; num3 > 509; num3 -= 510)
				{
					dst[dst_p++] = byte.MaxValue;
					dst[dst_p++] = byte.MaxValue;
				}
				if (num3 > 254)
				{
					num3 -= 255;
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num3;
			}
			else
			{
				dst[num2] += (byte)num3;
			}
			src_p += matchLength;
			src_anchor = src_p;
			return 0;
		}

		private static int LZ4_compressHCCtx_64(LZ4HC_Data_Structure ctx)
		{
			byte[] src = ctx.src;
			int src_base = ctx.src_base;
			int src_end = ctx.src_end;
			int dst_base = ctx.dst_base;
			int src_anchor = src_base;
			int num = src_end - 12;
			byte[] dst = ctx.dst;
			int dst_len = ctx.dst_len;
			int dst_p = ctx.dst_base;
			int matchpos = 0;
			int startpos = 0;
			int matchpos2 = 0;
			int startpos2 = 0;
			int matchpos3 = 0;
			src_base++;
			while (src_base < num)
			{
				int num2 = LZ4HC_InsertAndFindBestMatch_64(ctx, src_base, ref matchpos);
				if (num2 == 0)
				{
					src_base++;
					continue;
				}
				int num3 = src_base;
				int num4 = matchpos;
				int num5 = num2;
				while (true)
				{
					int num6 = ((src_base + num2 < num) ? LZ4HC_InsertAndGetWiderMatch_64(ctx, src_base + num2 - 2, src_base + 1, num2, ref matchpos2, ref startpos) : num2);
					if (num6 == num2)
					{
						if (LZ4_encodeSequence_64(ctx, ref src_base, ref dst_p, ref src_anchor, num2, matchpos) != 0)
						{
							return 0;
						}
						break;
					}
					if (num3 < src_base && startpos < src_base + num5)
					{
						src_base = num3;
						matchpos = num4;
						num2 = num5;
					}
					if (startpos - src_base < 3)
					{
						num2 = num6;
						src_base = startpos;
						matchpos = matchpos2;
						continue;
					}
					int num9;
					while (true)
					{
						if (startpos - src_base < 18)
						{
							int num7 = num2;
							if (num7 > 18)
							{
								num7 = 18;
							}
							if (src_base + num7 > startpos + num6 - 4)
							{
								num7 = startpos - src_base + num6 - 4;
							}
							int num8 = num7 - (startpos - src_base);
							if (num8 > 0)
							{
								startpos += num8;
								matchpos2 += num8;
								num6 -= num8;
							}
						}
						num9 = ((startpos + num6 < num) ? LZ4HC_InsertAndGetWiderMatch_64(ctx, startpos + num6 - 3, startpos, num6, ref matchpos3, ref startpos2) : num6);
						if (num9 == num6)
						{
							break;
						}
						if (startpos2 < src_base + num2 + 3)
						{
							if (startpos2 < src_base + num2)
							{
								startpos = startpos2;
								matchpos2 = matchpos3;
								num6 = num9;
								continue;
							}
							goto IL_0244;
						}
						if (startpos < src_base + num2)
						{
							if (startpos - src_base < 15)
							{
								if (num2 > 18)
								{
									num2 = 18;
								}
								if (src_base + num2 > startpos + num6 - 4)
								{
									num2 = startpos - src_base + num6 - 4;
								}
								int num10 = num2 - (startpos - src_base);
								if (num10 > 0)
								{
									startpos += num10;
									matchpos2 += num10;
									num6 -= num10;
								}
							}
							else
							{
								num2 = startpos - src_base;
							}
						}
						if (LZ4_encodeSequence_64(ctx, ref src_base, ref dst_p, ref src_anchor, num2, matchpos) != 0)
						{
							return 0;
						}
						src_base = startpos;
						matchpos = matchpos2;
						num2 = num6;
						startpos = startpos2;
						matchpos2 = matchpos3;
						num6 = num9;
					}
					if (startpos < src_base + num2)
					{
						num2 = startpos - src_base;
					}
					if (LZ4_encodeSequence_64(ctx, ref src_base, ref dst_p, ref src_anchor, num2, matchpos) != 0)
					{
						return 0;
					}
					src_base = startpos;
					if (LZ4_encodeSequence_64(ctx, ref src_base, ref dst_p, ref src_anchor, num6, matchpos2) != 0)
					{
						return 0;
					}
					break;
					IL_0244:
					if (startpos < src_base + num2)
					{
						int num11 = src_base + num2 - startpos;
						startpos += num11;
						matchpos2 += num11;
						num6 -= num11;
						if (num6 < 4)
						{
							startpos = startpos2;
							matchpos2 = matchpos3;
							num6 = num9;
						}
					}
					if (LZ4_encodeSequence_64(ctx, ref src_base, ref dst_p, ref src_anchor, num2, matchpos) != 0)
					{
						return 0;
					}
					src_base = startpos2;
					matchpos = matchpos3;
					num2 = num9;
					num3 = startpos;
					num4 = matchpos2;
					num5 = num6;
				}
			}
			int num12 = src_end - src_anchor;
			if (dst_p - dst_base + num12 + 1 + (num12 + 255 - 15) / 255 > (uint)dst_len)
			{
				return 0;
			}
			if (num12 >= 15)
			{
				dst[dst_p++] = 240;
				for (num12 -= 15; num12 > 254; num12 -= 255)
				{
					dst[dst_p++] = byte.MaxValue;
				}
				dst[dst_p++] = (byte)num12;
			}
			else
			{
				dst[dst_p++] = (byte)(num12 << 4);
			}
			BlockCopy(src, src_anchor, dst, dst_p, src_end - src_anchor);
			dst_p += src_end - src_anchor;
			return dst_p - dst_base;
		}
	}
}
namespace AssetsTools.NET
{
	public class AssetBundleBlockAndDirInfo
	{
		public Hash128 Hash { get; set; }

		public AssetBundleBlockInfo[] BlockInfos { get; set; }

		public List<AssetBundleDirectoryInfo> DirectoryInfos { get; set; }

		public void Read(AssetsFileReader reader)
		{
			Hash = new Hash128(reader.ReadBytes(16));
			int num = reader.ReadInt32();
			BlockInfos = new AssetBundleBlockInfo[num];
			for (int i = 0; i < num; i++)
			{
				BlockInfos[i] = new AssetBundleBlockInfo();
				BlockInfos[i].DecompressedSize = reader.ReadUInt32();
				BlockInfos[i].CompressedSize = reader.ReadUInt32();
				BlockInfos[i].Flags = reader.ReadUInt16();
			}
			int num2 = reader.ReadInt32();
			DirectoryInfos = new List<AssetBundleDirectoryInfo>(num2);
			for (int j = 0; j < num2; j++)
			{
				AssetBundleDirectoryInfo item = new AssetBundleDirectoryInfo
				{
					Offset = reader.ReadInt64(),
					DecompressedSize = reader.ReadInt64(),
					Flags = reader.ReadUInt32(),
					Name = reader.ReadNullTerminated()
				};
				DirectoryInfos.Add(item);
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			if (Hash.data == null)
			{
				writer.Write(0uL);
				writer.Write(0uL);
			}
			else
			{
				writer.Write(Hash.data);
			}
			int num = BlockInfos.Length;
			writer.Write(num);
			for (int i = 0; i < num; i++)
			{
				writer.Write(BlockInfos[i].DecompressedSize);
				writer.Write(BlockInfos[i].CompressedSize);
				writer.Write(BlockInfos[i].Flags);
			}
			int count = DirectoryInfos.Count;
			writer.Write(count);
			for (int j = 0; j < count; j++)
			{
				writer.Write(DirectoryInfos[j].Offset);
				writer.Write(DirectoryInfos[j].DecompressedSize);
				writer.Write(DirectoryInfos[j].Flags);
				writer.WriteNullTerminated(DirectoryInfos[j].Name);
			}
		}
	}
	public class AssetBundleBlockInfo
	{
		public uint DecompressedSize { get; set; }

		public uint CompressedSize { get; set; }

		public ushort Flags { get; set; }

		public byte GetCompressionType()
		{
			return (byte)(Flags & 0x3Fu);
		}
	}
	public class AssetBundleDirectoryInfo
	{
		public long Offset;

		public long DecompressedSize;

		public uint Flags;

		public string Name;

		public IContentReplacer Replacer { get; set; }

		public ContentReplacerType ReplacerType => (Replacer != null) ? Replacer.GetReplacerType() : ContentReplacerType.None;

		public bool IsReplacerPreviewable => Replacer != null && Replacer.HasPreview();

		public void SetNewData(byte[] newBytes)
		{
			Replacer = new ContentReplacerFromBuffer(newBytes);
		}

		public void SetNewData(AssetsFile assetsFile)
		{
			Replacer = new ContentReplacerFromAssets(assetsFile);
		}

		public void SetRemoved()
		{
			Replacer = new ContentRemover();
		}

		public static AssetBundleDirectoryInfo Create(string name, bool isSerialized)
		{
			return new AssetBundleDirectoryInfo
			{
				Offset = -1L,
				DecompressedSize = 0L,
				Flags = (isSerialized ? 4u : 0u),
				Name = name
			};
		}
	}
	public class AssetBundleFile
	{
		public AssetsFileReader Reader;

		public AssetBundleHeader Header { get; set; }

		public AssetBundleBlockAndDirInfo BlockAndDirInfo { get; set; }

		public AssetsFileReader DataReader { get; set; }

		public bool DataIsCompressed { get; set; }

		public void Close()
		{
			Reader.Close();
			DataReader.Close();
		}

		public void Read(AssetsFileReader reader)
		{
			Reader = reader;
			Reader.Position = 0L;
			Reader.BigEndian = true;
			string text = reader.ReadNullTerminated();
			uint num = reader.ReadUInt32();
			if (num >= 6 || num <= 8)
			{
				Reader.Position = 0L;
				Header = new AssetBundleHeader();
				Header.Read(reader);
				if (Header.Version >= 7)
				{
					reader.Align16();
				}
				if (Header.Signature == "UnityFS")
				{
					UnpackInfoOnly();
				}
				else
				{
					new NotImplementedException("Non UnityFS bundles are not supported yet.");
				}
			}
			else
			{
				new NotImplementedException($"Version {num} bundles are not supported yet.");
			}
		}

		public void Write(AssetsFileWriter writer, long filePos = 0L)
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			if (Header.Signature != "UnityFS")
			{
				throw new NotImplementedException("Non UnityFS bundles are not supported yet.");
			}
			if (DataIsCompressed)
			{
				throw new Exception("Bundles must be decompressed before writing.");
			}
			long position = filePos;
			if (filePos == -1)
			{
				position = writer.Position;
			}
			else
			{
				writer.Position = filePos;
			}
			List<AssetBundleDirectoryInfo> directoryInfos = BlockAndDirInfo.DirectoryInfos;
			Header.Write(writer);
			if (Header.Version >= 7)
			{
				writer.Align16();
			}
			AssetBundleBlockInfo assetBundleBlockInfo = new AssetBundleBlockInfo
			{
				CompressedSize = 0u,
				DecompressedSize = 0u,
				Flags = 64
			};
			AssetBundleBlockAndDirInfo assetBundleBlockAndDirInfo = new AssetBundleBlockAndDirInfo();
			assetBundleBlockAndDirInfo.Hash = default(Hash128);
			assetBundleBlockAndDirInfo.BlockInfos = new AssetBundleBlockInfo[1] { assetBundleBlockInfo };
			AssetBundleBlockAndDirInfo assetBundleBlockAndDirInfo2 = assetBundleBlockAndDirInfo;
			List<AssetBundleDirectoryInfo> list = new List<AssetBundleDirectoryInfo>();
			int count = directoryInfos.Count;
			for (int i = 0; i < count; i++)
			{
				AssetBundleDirectoryInfo assetBundleDirectoryInfo = directoryInfos[i];
				ContentReplacerType replacerType = assetBundleDirectoryInfo.ReplacerType;
				if (replacerType != ContentReplacerType.Remove)
				{
					list.Add(new AssetBundleDirectoryInfo
					{
						Offset = assetBundleDirectoryInfo.Offset,
						DecompressedSize = assetBundleDirectoryInfo.DecompressedSize,
						Flags = assetBundleDirectoryInfo.Flags,
						Name = assetBundleDirectoryInfo.Name,
						Replacer = assetBundleDirectoryInfo.Replacer
					});
				}
			}
			long position2 = writer.Position;
			assetBundleBlockAndDirInfo2.DirectoryInfos = list;
			assetBundleBlockAndDirInfo2.Write(writer);
			if ((Header.FileStreamHeader.Flags & AssetBundleFSHeaderFlags.BlockInfoNeedPaddingAtStart) != 0)
			{
				writer.Align16();
			}
			long position3 = writer.Position;
			for (int j = 0; j < list.Count; j++)
			{
				AssetBundleDirectoryInfo assetBundleDirectoryInfo2 = list[j];
				long position4 = writer.Position;
				long offset = position4 - position3;
				ContentReplacerType replacerType2 = assetBundleDirectoryInfo2.ReplacerType;
				if (replacerType2 == ContentReplacerType.AddOrModify)
				{
					assetBundleDirectoryInfo2.Replacer.Write(writer);
				}
				else
				{
					DataReader.Position = assetBundleDirectoryInfo2.Offset;
					DataReader.BaseStream.CopyToCompat(writer.BaseStream, assetBundleDirectoryInfo2.DecompressedSize);
				}
				assetBundleDirectoryInfo2.Offset = offset;
				assetBundleDirectoryInfo2.DecompressedSize = writer.Position - position4;
			}
			long position5 = writer.Position;
			if (position5 - position3 > uint.MaxValue)
			{
				throw new NotImplementedException("Data larger than max uint not supported yet.");
			}
			uint num = (uint)(position5 - position3);
			writer.Position = position2;
			assetBundleBlockInfo.DecompressedSize = num;
			assetBundleBlockInfo.CompressedSize = num;
			assetBundleBlockAndDirInfo2.DirectoryInfos = list;
			assetBundleBlockAndDirInfo2.Write(writer);
			uint num2 = (uint)(position3 - position2);
			writer.Position = position;
			AssetBundleHeader assetBundleHeader = new AssetBundleHeader
			{
				Signature = Header.Signature,
				Version = Header.Version,
				GenerationVersion = Header.GenerationVersion,
				EngineVersion = Header.EngineVersion,
				FileStreamHeader = new AssetBundleFSHeader
				{
					TotalFileSize = position5,
					CompressedSize = num2,
					DecompressedSize = num2,
					Flags = (Header.FileStreamHeader.Flags & (AssetBundleFSHeaderFlags)(-129) & (AssetBundleFSHeaderFlags)(-64))
				}
			};
			assetBundleHeader.Write(writer);
		}

		public void Unpack(AssetsFileWriter writer)
		{
			if (Header == null)
			{
				new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			if (Header.Signature != "UnityFS")
			{
				new NotImplementedException("Non UnityFS bundles are not supported yet.");
			}
			AssetBundleFSHeader fileStreamHeader = Header.FileStreamHeader;
			AssetsFileReader dataReader = DataReader;
			AssetBundleBlockInfo[] blockInfos = BlockAndDirInfo.BlockInfos;
			List<AssetBundleDirectoryInfo> directoryInfos = BlockAndDirInfo.DirectoryInfos;
			AssetBundleHeader assetBundleHeader = new AssetBundleHeader
			{
				Signature = Header.Signature,
				Version = Header.Version,
				GenerationVersion = Header.GenerationVersion,
				EngineVersion = Header.EngineVersion,
				FileStreamHeader = new AssetBundleFSHeader
				{
					TotalFileSize = 0L,
					CompressedSize = fileStreamHeader.DecompressedSize,
					DecompressedSize = fileStreamHeader.DecompressedSize,
					Flags = (AssetBundleFSHeaderFlags.HasDirectoryInfo | (((fileStreamHeader.Flags & AssetBundleFSHeaderFlags.BlockInfoNeedPaddingAtStart) != 0) ? AssetBundleFSHeaderFlags.BlockInfoNeedPaddingAtStart : AssetBundleFSHeaderFlags.None))
				}
			};
			long num = assetBundleHeader.GetFileDataOffset();
			for (int i = 0; i < blockInfos.Length; i++)
			{
				num += blockInfos[i].DecompressedSize;
			}
			assetBundleHeader.FileStreamHeader.TotalFileSize = num;
			AssetBundleBlockAndDirInfo assetBundleBlockAndDirInfo = new AssetBundleBlockAndDirInfo();
			assetBundleBlockAndDirInfo.Hash = default(Hash128);
			assetBundleBlockAndDirInfo.BlockInfos = new AssetBundleBlockInfo[blockInfos.Length];
			assetBundleBlockAndDirInfo.DirectoryInfos = new List<AssetBundleDirectoryInfo>(directoryInfos.Count);
			AssetBundleBlockAndDirInfo assetBundleBlockAndDirInfo2 = assetBundleBlockAndDirInfo;
			for (int j = 0; j < blockInfos.Length; j++)
			{
				assetBundleBlockAndDirInfo2.BlockInfos[j] = new AssetBundleBlockInfo
				{
					CompressedSize = blockInfos[j].DecompressedSize,
					DecompressedSize = blockInfos[j].DecompressedSize,
					Flags = (ushort)(blockInfos[j].Flags & 0xFFFFFFC0u)
				};
			}
			for (int k = 0; k < directoryInfos.Count; k++)
			{
				assetBundleBlockAndDirInfo2.DirectoryInfos.Add(new AssetBundleDirectoryInfo
				{
					Offset = directoryInfos[k].Offset,
					DecompressedSize = directoryInfos[k].DecompressedSize,
					Flags = directoryInfos[k].Flags,
					Name = directoryInfos[k].Name
				});
			}
			assetBundleHeader.Write(writer);
			if (assetBundleHeader.Version >= 7)
			{
				writer.Align16();
			}
			assetBundleBlockAndDirInfo2.Write(writer);
			if ((assetBundleHeader.FileStreamHeader.Flags & AssetBundleFSHeaderFlags.BlockInfoNeedPaddingAtStart) != 0)
			{
				writer.Align16();
			}
			dataReader.Position = 0L;
			if (DataIsCompressed)
			{
				for (int l = 0; l < assetBundleBlockAndDirInfo2.BlockInfos.Length; l++)
				{
					AssetBundleBlockInfo assetBundleBlockInfo = blockInfos[l];
					switch (assetBundleBlockInfo.GetCompressionType())
					{
					case 0:
						dataReader.BaseStream.CopyToCompat(writer.BaseStream, assetBundleBlockInfo.CompressedSize);
						break;
					case 1:
						SevenZipHelper.StreamDecompress(dataReader.BaseStream, writer.BaseStream, assetBundleBlockInfo.CompressedSize, assetBundleBlockInfo.DecompressedSize);
						break;
					case 2:
					case 3:
					{
						using (MemoryStream memoryStream = new MemoryStream())
						{
							dataReader.BaseStream.CopyToCompat(memoryStream, assetBundleBlockInfo.CompressedSize);
							memoryStream.Position = 0L;
							using Lz4DecoderStream input = new Lz4DecoderStream(memoryStream);
							input.CopyToCompat(writer.BaseStream, assetBundleBlockInfo.DecompressedSize);
						}
						break;
					}
					}
				}
			}
			else
			{
				for (int m = 0; m < assetBundleBlockAndDirInfo2.BlockInfos.Length; m++)
				{
					AssetBundleBlockInfo assetBundleBlockInfo2 = blockInfos[m];
					dataReader.BaseStream.CopyToCompat(writer.BaseStream, assetBundleBlockInfo2.DecompressedSize);
				}
			}
		}

		public void Pack(AssetsFileWriter writer, AssetBundleCompressionType compType, bool blockDirAtEnd = true, IAssetBundleCompressProgress progress = null)
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			if (Header.Signature != "UnityFS")
			{
				throw new NotImplementedException("Non UnityFS bundles are not supported yet.");
			}
			if (DataIsCompressed)
			{
				throw new Exception("Bundles must be decompressed before writing.");
			}
			Reader.Position = 0L;
			writer.Position = 0L;
			AssetBundleFSHeader assetBundleFSHeader = new AssetBundleFSHeader
			{
				TotalFileSize = 0L,
				CompressedSize = 0u,
				DecompressedSize = 0u,
				Flags = ((AssetBundleFSHeaderFlags)67 | (blockDirAtEnd ? AssetBundleFSHeaderFlags.BlockAndDirAtEnd : AssetBundleFSHeaderFlags.None))
			};
			AssetBundleHeader assetBundleHeader = new AssetBundleHeader
			{
				Signature = Header.Signature,
				Version = Header.Version,
				GenerationVersion = Header.GenerationVersion,
				EngineVersion = Header.EngineVersion,
				FileStreamHeader = assetBundleFSHeader
			};
			AssetBundleBlockAndDirInfo assetBundleBlockAndDirInfo = new AssetBundleBlockAndDirInfo
			{
				Hash = default(Hash128),
				BlockInfos = null,
				DirectoryInfos = BlockAndDirInfo.DirectoryInfos
			};
			long position = writer.Position;
			assetBundleHeader.Write(writer);
			if (assetBundleHeader.Version >= 7)
			{
				writer.Align16();
			}
			int num = (int)(writer.Position - position);
			long num2 = 0L;
			List<AssetBundleBlockInfo> list = new List<AssetBundleBlockInfo>();
			List<Stream> list2 = new List<Stream>();
			Stream baseStream = DataReader.BaseStream;
			baseStream.Position = 0L;
			int num3 = (int)baseStream.Length;
			switch (compType)
			{
			case AssetBundleCompressionType.LZMA:
			{
				Stream stream2 = ((!blockDirAtEnd) ? GetTempFileStream() : writer.BaseStream);
				AssetBundleLZMAProgress progress2 = new AssetBundleLZMAProgress(progress, baseStream.Length);
				long position2 = stream2.Position;
				SevenZipHelper.Compress(baseStream, stream2, progress2);
				uint compressedSize = (uint)(stream2.Position - position2);
				AssetBundleBlockInfo assetBundleBlockInfo4 = new AssetBundleBlockInfo
				{
					CompressedSize = compressedSize,
					DecompressedSize = (uint)num3,
					Flags = 65
				};
				num2 += assetBundleBlockInfo4.CompressedSize;
				list.Add(assetBundleBlockInfo4);
				if (!blockDirAtEnd)
				{
					list2.Add(stream2);
				}
				progress?.SetProgress(1f);
				break;
			}
			case AssetBundleCompressionType.LZ4:
			{
				BinaryReader binaryReader = new BinaryReader(baseStream);
				Stream stream = ((!blockDirAtEnd) ? GetTempFileStream() : writer.BaseStream);
				byte[] array = binaryReader.ReadBytes(131072);
				while (array.Length != 0)
				{
					byte[] array2 = LZ4Codec.Encode32HC(array, 0, array.Length);
					progress?.SetProgress((float)binaryReader.BaseStream.Position / (float)binaryReader.BaseStream.Length);
					if (array2.Length > array.Length)
					{
						stream.Write(array, 0, array.Length);
						AssetBundleBlockInfo assetBundleBlockInfo2 = new AssetBundleBlockInfo
						{
							CompressedSize = (uint)array.Length,
							DecompressedSize = (uint)array.Length,
							Flags = 0
						};
						num2 += assetBundleBlockInfo2.CompressedSize;
						list.Add(assetBundleBlockInfo2);
					}
					else
					{
						stream.Write(array2, 0, array2.Length);
						AssetBundleBlockInfo assetBundleBlockInfo3 = new AssetBundleBlockInfo
						{
							CompressedSize = (uint)array2.Length,
							DecompressedSize = (uint)array.Length,
							Flags = 3
						};
						num2 += assetBundleBlockInfo3.CompressedSize;
						list.Add(assetBundleBlockInfo3);
					}
					array = binaryReader.ReadBytes(131072);
				}
				if (!blockDirAtEnd)
				{
					list2.Add(stream);
				}
				progress?.SetProgress(1f);
				break;
			}
			case AssetBundleCompressionType.None:
			{
				AssetBundleBlockInfo assetBundleBlockInfo = new AssetBundleBlockInfo
				{
					CompressedSize = (uint)num3,
					DecompressedSize = (uint)num3,
					Flags = 0
				};
				num2 += assetBundleBlockInfo.CompressedSize;
				list.Add(assetBundleBlockInfo);
				if (blockDirAtEnd)
				{
					baseStream.CopyToCompat(writer.BaseStream, -1L);
				}
				else
				{
					list2.Add(baseStream);
				}
				break;
			}
			}
			assetBundleBlockAndDirInfo.BlockInfos = list.ToArray();
			byte[] array3;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				AssetsFileWriter assetsFileWriter = new AssetsFileWriter(memoryStream);
				assetsFileWriter.BigEndian = writer.BigEndian;
				assetBundleBlockAndDirInfo.Write(assetsFileWriter);
				array3 = memoryStream.ToArray();
			}
			byte[] array4 = LZ4Codec.Encode32HC(array3, 0, array3.Length);
			long totalFileSize = num + array4.Length + num2;
			assetBundleFSHeader.TotalFileSize = totalFileSize;
			assetBundleFSHeader.DecompressedSize = (uint)array3.Length;
			assetBundleFSHeader.CompressedSize = (uint)array4.Length;
			if (!blockDirAtEnd)
			{
				writer.Write(array4);
				foreach (Stream item in list2)
				{
					item.Position = 0L;
					item.CopyToCompat(writer.BaseStream, -1L);
					item.Close();
				}
			}
			else
			{
				writer.Write(array4);
			}
			writer.Position = 0L;
			assetBundleHeader.Write(writer);
			if (assetBundleHeader.Version >= 7)
			{
				writer.Align16();
			}
		}

		private void UnpackInfoOnly()
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			Reader.Position = Header.GetBundleInfoOffset();
			if (Header.GetCompressionType() == 0)
			{
				BlockAndDirInfo = new AssetBundleBlockAndDirInfo();
				BlockAndDirInfo.Read(Reader);
			}
			else
			{
				int compressedSize = (int)Header.FileStreamHeader.CompressedSize;
				int decompressedSize = (int)Header.FileStreamHeader.DecompressedSize;
				MemoryStream memoryStream;
				switch (Header.GetCompressionType())
				{
				case 1:
				{
					using (MemoryStream compressedStream = new MemoryStream(Reader.ReadBytes(compressedSize)))
					{
						memoryStream = new MemoryStream();
						SevenZipHelper.StreamDecompress(compressedStream, memoryStream, compressedSize, decompressedSize);
					}
					break;
				}
				case 2:
				case 3:
				{
					byte[] buffer = new byte[Header.FileStreamHeader.DecompressedSize];
					using (MemoryStream input = new MemoryStream(Reader.ReadBytes(compressedSize)))
					{
						Lz4DecoderStream lz4DecoderStream = new Lz4DecoderStream(input);
						lz4DecoderStream.Read(buffer, 0, (int)Header.FileStreamHeader.DecompressedSize);
						lz4DecoderStream.Dispose();
					}
					memoryStream = new MemoryStream(buffer);
					break;
				}
				default:
					memoryStream = null;
					break;
				}
				AssetsFileReader assetsFileReader;
				using (assetsFileReader = new AssetsFileReader(memoryStream))
				{
					assetsFileReader.Position = 0L;
					assetsFileReader.BigEndian = Reader.BigEndian;
					BlockAndDirInfo = new AssetBundleBlockAndDirInfo();
					BlockAndDirInfo.Read(assetsFileReader);
				}
			}
			switch (GetCompressionType())
			{
			case AssetBundleCompressionType.None:
			{
				SegmentStream stream3 = new SegmentStream(Reader.BaseStream, Header.GetFileDataOffset());
				DataReader = new AssetsFileReader(stream3);
				DataIsCompressed = false;
				break;
			}
			case AssetBundleCompressionType.LZMA:
			{
				SegmentStream stream2 = new SegmentStream(Reader.BaseStream, Header.GetFileDataOffset());
				DataReader = new AssetsFileReader(stream2);
				DataIsCompressed = true;
				break;
			}
			case AssetBundleCompressionType.LZ4:
			{
				LZ4BlockStream stream = new LZ4BlockStream(Reader.BaseStream, Header.GetFileDataOffset(), BlockAndDirInfo.BlockInfos);
				DataReader = new AssetsFileReader(stream);
				DataIsCompressed = false;
				break;
			}
			}
		}

		public AssetBundleCompressionType GetCompressionType()
		{
			AssetBundleBlockInfo[] blockInfos = BlockAndDirInfo.BlockInfos;
			for (int i = 0; i < blockInfos.Length; i++)
			{
				byte compressionType = blockInfos[i].GetCompressionType();
				if (compressionType == 2 || compressionType == 3)
				{
					return AssetBundleCompressionType.LZ4;
				}
				if (compressionType == 1)
				{
					return AssetBundleCompressionType.LZMA;
				}
			}
			return AssetBundleCompressionType.None;
		}

		public bool IsAssetsFile(int index)
		{
			GetFileRange(index, out var offset, out var length);
			return AssetsFile.IsAssetsFile(DataReader, offset, length);
		}

		public int GetFileIndex(string name)
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			for (int i = 0; i < BlockAndDirInfo.DirectoryInfos.Count; i++)
			{
				if (BlockAndDirInfo.DirectoryInfos[i].Name == name)
				{
					return i;
				}
			}
			return -1;
		}

		public string GetFileName(int index)
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			if (index < 0 || index >= BlockAndDirInfo.DirectoryInfos.Count)
			{
				return null;
			}
			return BlockAndDirInfo.DirectoryInfos[index].Name;
		}

		public void GetFileRange(int index, out long offset, out long length)
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			if (index < 0 || index >= BlockAndDirInfo.DirectoryInfos.Count)
			{
				offset = -1L;
				length = 0L;
			}
			else
			{
				AssetBundleDirectoryInfo assetBundleDirectoryInfo = BlockAndDirInfo.DirectoryInfos[index];
				offset = assetBundleDirectoryInfo.Offset;
				length = assetBundleDirectoryInfo.DecompressedSize;
			}
		}

		public List<string> GetAllFileNames()
		{
			if (Header == null)
			{
				throw new Exception("Header must be loaded! (Did you forget to call bundle.Read?)");
			}
			List<string> list = new List<string>();
			List<AssetBundleDirectoryInfo> directoryInfos = BlockAndDirInfo.DirectoryInfos;
			foreach (AssetBundleDirectoryInfo item in directoryInfos)
			{
				list.Add(item.Name);
			}
			return list;
		}

		private FileStream GetTempFileStream()
		{
			string tempFileName = Path.GetTempFileName();
			return new FileStream(tempFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read, 4096, FileOptions.DeleteOnClose);
		}
	}
	public enum AssetBundleCompressionType
	{
		None,
		LZMA,
		LZ4
	}
	public class AssetBundleFSHeader
	{
		public long TotalFileSize { get; set; }

		public uint CompressedSize { get; set; }

		public uint DecompressedSize { get; set; }

		public AssetBundleFSHeaderFlags Flags { get; set; }

		public void Read(AssetsFileReader reader)
		{
			TotalFileSize = reader.ReadInt64();
			CompressedSize = reader.ReadUInt32();
			DecompressedSize = reader.ReadUInt32();
			Flags = (AssetBundleFSHeaderFlags)reader.ReadUInt32();
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(TotalFileSize);
			writer.Write(CompressedSize);
			writer.Write(DecompressedSize);
			writer.Write((uint)Flags);
		}
	}
	public enum AssetBundleFSHeaderFlags
	{
		None = 0,
		LZMACompressed = 1,
		LZ4Compressed = 2,
		LZ4HCCompressed = 3,
		CompressionMask = 63,
		HasDirectoryInfo = 64,
		BlockAndDirAtEnd = 128,
		OldWebPluginCompatibility = 256,
		BlockInfoNeedPaddingAtStart = 512
	}
	public class AssetBundleHeader
	{
		public string Signature { get; set; }

		public uint Version { get; set; }

		public string GenerationVersion { get; set; }

		public string EngineVersion { get; set; }

		public AssetBundleFSHeader FileStreamHeader { get; set; }

		public void Read(AssetsFileReader reader)
		{
			reader.BigEndian = true;
			Signature = reader.ReadNullTerminated();
			Version = reader.ReadUInt32();
			GenerationVersion = reader.ReadNullTerminated();
			EngineVersion = reader.ReadNullTerminated();
			if (Signature == "UnityFS")
			{
				FileStreamHeader = new AssetBundleFSHeader();
				FileStreamHeader.Read(reader);
				return;
			}
			throw new NotSupportedException(Signature + " signature not supported!");
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.BigEndian = true;
			writer.WriteNullTerminated(Signature);
			writer.Write(Version);
			writer.WriteNullTerminated(GenerationVersion);
			writer.WriteNullTerminated(EngineVersion);
			if (Signature == "UnityFS")
			{
				FileStreamHeader.Write(writer);
				return;
			}
			throw new NotSupportedException(Signature + " signature not supported!");
		}

		public long GetBundleInfoOffset()
		{
			if (Signature != "UnityFS")
			{
				throw new NotSupportedException(Signature + " signature not supported!");
			}
			AssetBundleFSHeaderFlags flags = FileStreamHeader.Flags;
			long totalFileSize = FileStreamHeader.TotalFileSize;
			long num = FileStreamHeader.CompressedSize;
			if ((flags & AssetBundleFSHeaderFlags.BlockAndDirAtEnd) != 0)
			{
				if (totalFileSize == 0)
				{
					return -1L;
				}
				return totalFileSize - num;
			}
			long num2 = GenerationVersion.Length + EngineVersion.Length + 26;
			if (Version >= 7)
			{
				if ((flags & AssetBundleFSHeaderFlags.OldWebPluginCompatibility) != 0)
				{
					return (num2 + 10 + 15) & -16;
				}
				return (num2 + Signature.Length + 1 + 15) & -16;
			}
			if ((flags & AssetBundleFSHeaderFlags.OldWebPluginCompatibility) != 0)
			{
				return num2 + 10;
			}
			return num2 + Signature.Length + 1;
		}

		public long GetFileDataOffset()
		{
			if (Signature != "UnityFS")
			{
				throw new NotSupportedException(Signature + " signature not supported!");
			}
			AssetBundleFSHeaderFlags flags = FileStreamHeader.Flags;
			long num = FileStreamHeader.CompressedSize;
			long num2 = GenerationVersion.Length + EngineVersion.Length + 26;
			num2 = (((flags & AssetBundleFSHeaderFlags.OldWebPluginCompatibility) == 0) ? (num2 + (Signature.Length + 1)) : (num2 + 10));
			if (Version >= 7)
			{
				num2 = (num2 + 15) & -16;
			}
			if ((flags & AssetBundleFSHeaderFlags.BlockAndDirAtEnd) == 0)
			{
				num2 += num;
			}
			if ((flags & AssetBundleFSHeaderFlags.BlockInfoNeedPaddingAtStart) != 0)
			{
				num2 = (num2 + 15) & -16;
			}
			return num2;
		}

		public byte GetCompressionType()
		{
			if (Signature != "UnityFS")
			{
				throw new NotSupportedException(Signature + " signature not supported!");
			}
			return (byte)(FileStreamHeader.Flags & AssetBundleFSHeaderFlags.CompressionMask);
		}
	}
	internal class AssetBundleLZMAProgress : ICodeProgress
	{
		private IAssetBundleCompressProgress progress;

		private long currentSize;

		private long length;

		public AssetBundleLZMAProgress(IAssetBundleCompressProgress progress, long length)
		{
			this.progress = progress;
			currentSize = 0L;
			this.length = length;
		}

		public void SetProgress(long inSize, long outSize)
		{
			if (progress != null)
			{
				progress.SetProgress((float)inSize / (float)length);
			}
		}
	}
	public interface IAssetBundleCompressProgress
	{
		void SetProgress(float progress);
	}
	public class AssetFileInfo
	{
		public long PathId { get; set; }

		public long ByteOffset { get; set; }

		public uint ByteSize { get; set; }

		public int TypeIdOrIndex { get; set; }

		public ushort OldTypeId { get; set; }

		public ushort ScriptTypeIndex { get; set; }

		public byte Stripped { get; set; }

		public int TypeId { get; set; }

		public IContentReplacer Replacer { get; set; }

		public ContentReplacerType ReplacerType => (Replacer != null) ? Replacer.GetReplacerType() : ContentReplacerType.None;

		public bool IsReplacerPreviewable => Replacer != null && Replacer.HasPreview();

		public void Read(AssetsFileReader reader, uint version)
		{
			reader.Align();
			if (version >= 14)
			{
				PathId = reader.ReadInt64();
			}
			else
			{
				PathId = reader.ReadUInt32();
			}
			if (version >= 22)
			{
				ByteOffset = reader.ReadInt64();
			}
			else
			{
				ByteOffset = reader.ReadUInt32();
			}
			ByteSize = reader.ReadUInt32();
			TypeIdOrIndex = reader.ReadInt32();
			if (version <= 15)
			{
				OldTypeId = reader.ReadUInt16();
			}
			if (version <= 16)
			{
				ScriptTypeIndex = reader.ReadUInt16();
			}
			if (15 <= version && version <= 16)
			{
				Stripped = reader.ReadByte();
			}
			Replacer = null;
		}

		public void Write(AssetsFileWriter writer, uint version)
		{
			writer.Align();
			if (version >= 14)
			{
				writer.Write(PathId);
			}
			else
			{
				writer.Write((uint)PathId);
			}
			if (version >= 22)
			{
				writer.Write(ByteOffset);
			}
			else
			{
				writer.Write((uint)ByteOffset);
			}
			writer.Write(ByteSize);
			writer.Write(TypeIdOrIndex);
			if (version <= 15)
			{
				writer.Write(OldTypeId);
			}
			if (version <= 16)
			{
				writer.Write(ScriptTypeIndex);
			}
			if (15 <= version && version <= 16)
			{
				writer.Write(Stripped);
			}
		}

		public int GetTypeId(AssetsFile assetsFile)
		{
			return GetTypeId(assetsFile.Metadata.TypeTreeTypes, assetsFile.Header.Version);
		}

		public int GetTypeId(AssetsFileMetadata metadata, uint version)
		{
			return GetTypeId(metadata.TypeTreeTypes, version);
		}

		public int GetTypeId(List<TypeTreeType> typeTreeTypes, uint version)
		{
			if (version < 16)
			{
				return TypeIdOrIndex;
			}
			if (TypeIdOrIndex >= typeTreeTypes.Count)
			{
				throw new IndexOutOfRangeException("TypeIndex is larger than type tree count!");
			}
			return typeTreeTypes[TypeIdOrIndex].TypeId;
		}

		public long GetAbsoluteByteOffset(AssetsFile assetsFile)
		{
			return assetsFile.Header.DataOffset + ByteOffset;
		}

		public long GetAbsoluteByteOffset(AssetsFileHeader header)
		{
			return header.DataOffset + ByteOffset;
		}

		public long GetAbsoluteByteOffset(long dataOffset)
		{
			return dataOffset + ByteOffset;
		}

		public void SetNewData(byte[] newBytes)
		{
			Replacer = new ContentReplacerFromBuffer(newBytes);
		}

		public void SetNewData(AssetTypeValueField baseField)
		{
			Replacer = new ContentReplacerFromBuffer(baseField.WriteToByteArray());
		}

		public void SetRemoved()
		{
			Replacer = new ContentRemover();
		}

		public static AssetFileInfo Create(AssetsFile assetsFile, long pathId, int typeId, ClassDatabaseFile classDatabase = null, bool preferEditor = false)
		{
			return Create(assetsFile, pathId, typeId, ushort.MaxValue, classDatabase, preferEditor);
		}

		public static AssetFileInfo Create(AssetsFile assetsFile, long pathId, int typeId, ushort scriptIndex = ushort.MaxValue, ClassDatabaseFile classDatabase = null, bool preferEditor = false)
		{
			uint version = assetsFile.Header.Version;
			int typeIdOrIndex;
			ushort oldTypeId;
			if (version >= 16)
			{
				int num = assetsFile.Metadata.FindTypeTreeTypeIndexByID(typeId, scriptIndex);
				if (num == -1)
				{
					if (classDatabase == null)
					{
						return null;
					}
					TypeTreeType typeTreeType;
					if (assetsFile.Metadata.TypeTreeEnabled)
					{
						typeTreeType = ClassDatabaseToTypeTree.Convert(classDatabase, typeId, preferEditor);
						if (typeTreeType == null)
						{
							return null;
						}
					}
					else
					{
						TypeTreeType typeTreeType2 = new TypeTreeType();
						typeTreeType2.TypeId = typeId;
						typeTreeType2.IsStrippedType = false;
						typeTreeType2.ScriptTypeIndex = scriptIndex;
						typeTreeType2.ScriptIdHash = Hash128.NewBlankHash();
						typeTreeType2.TypeHash = Hash128.NewBlankHash();
						typeTreeType2.Nodes = new List<TypeTreeNode>();
						typeTreeType2.StringBufferBytes = new byte[0];
						typeTreeType2.TypeDependencies = new int[0];
						typeTreeType2.IsRefType = false;
						typeTreeType2.TypeReference = null;
						typeTreeType = typeTreeType2;
					}
					typeIdOrIndex = assetsFile.Metadata.TypeTreeTypes.Count;
					assetsFile.Metadata.TypeTreeTypes.Add(typeTreeType);
				}
				else
				{
					typeIdOrIndex = num;
				}
				oldTypeId = 0;
			}
			else
			{
				typeIdOrIndex = typeId;
				oldTypeId = (ushort)((typeId >= 0) ? ((ushort)typeId) : 114);
			}
			ushort scriptTypeIndex = (ushort)((version < 17) ? scriptIndex : 0);
			return new AssetFileInfo
			{
				PathId = pathId,
				ByteOffset = -1L,
				ByteSize = 0u,
				TypeIdOrIndex = typeIdOrIndex,
				OldTypeId = oldTypeId,
				ScriptTypeIndex = scriptTypeIndex,
				Stripped = 0,
				TypeId = typeId,
				Replacer = null
			};
		}
	}
	public class AssetPPtr
	{
		public string FilePath { get; set; }

		public int FileId { get; set; }

		public long PathId { get; set; }

		public AssetPPtr()
		{
			FilePath = string.Empty;
			FileId = 0;
			PathId = 0L;
		}

		public AssetPPtr(int fileId, long pathId)
		{
			FilePath = string.Empty;
			FileId = fileId;
			PathId = pathId;
		}

		public AssetPPtr(string fileName, long pathId)
		{
			FilePath = fileName;
			FileId = 0;
			PathId = pathId;
		}

		public AssetPPtr(string fileName, int fileId, long pathId)
		{
			FilePath = fileName;
			FileId = fileId;
			PathId = pathId;
		}

		public bool HasFilePath()
		{
			return FilePath != string.Empty && FilePath != null;
		}

		public bool IsNull()
		{
			if (HasFilePath())
			{
				return PathId == 0;
			}
			return FileId == 0 && PathId == 0;
		}

		public void SetFilePathFromFile(AssetsFile file)
		{
			int num = FileId - 1;
			if (FileId > 0 && file.Metadata.Externals.Count < num)
			{
				FilePath = file.Metadata.Externals[num].PathName;
			}
		}

		public void SetFilePathFromFile(AssetsManager am, AssetsFileInstance fileInst)
		{
			if (FileId == 0)
			{
				FilePath = fileInst.path;
				return;
			}
			int depIdx = FileId - 1;
			AssetsFileInstance dependency = fileInst.GetDependency(am, depIdx);
			if (dependency != null)
			{
				FilePath = dependency.path;
			}
		}

		public static AssetPPtr FromField(AssetTypeValueField field)
		{
			return new AssetPPtr(field["m_FileID"].AsInt, field["m_PathID"].AsLong);
		}

		public override bool Equals(object obj)
		{
			if (!(obj is AssetPPtr))
			{
				return false;
			}
			AssetPPtr assetPPtr = (AssetPPtr)obj;
			if (assetPPtr.HasFilePath() && HasFilePath())
			{
				return assetPPtr.PathId == PathId && assetPPtr.FilePath == FilePath;
			}
			if (!assetPPtr.HasFilePath() && !HasFilePath())
			{
				return assetPPtr.PathId == PathId && assetPPtr.FileId == FileId;
			}
			return false;
		}

		public override int GetHashCode()
		{
			int num = 17;
			num = num * 23 + (HasFilePath() ? FilePath.GetHashCode() : FileId.GetHashCode());
			return num * 23 + PathId.GetHashCode();
		}
	}
	public class AssetsFile
	{
		public AssetsFileHeader Header { get; set; }

		public AssetsFileMetadata Metadata { get; set; }

		public AssetsFileReader Reader { get; set; }

		public IList<AssetFileInfo> AssetInfos => Metadata.AssetInfos;

		public void Close()
		{
			Reader.Close();
		}

		public void Read(AssetsFileReader reader)
		{
			Reader = reader;
			Header = new AssetsFileHeader();
			Header.Read(reader);
			Metadata = new AssetsFileMetadata();
			Metadata.Read(reader, Header);
		}

		public void Read(Stream stream)
		{
			Read(new AssetsFileReader(stream));
		}

		public void Write(AssetsFileWriter writer, long filePos = 0L)
		{
			long num = filePos;
			if (filePos == -1)
			{
				num = writer.Position;
			}
			else
			{
				writer.Position = filePos;
			}
			Header.Write(writer);
			List<AssetFileInfo> list = new List<AssetFileInfo>();
			int count = Metadata.AssetInfos.Count;
			for (int j = 0; j < count; j++)
			{
				AssetFileInfo assetFileInfo = Metadata.AssetInfos[j];
				ContentReplacerType replacerType = assetFileInfo.ReplacerType;
				if (replacerType != ContentReplacerType.Remove)
				{
					if (replacerType == ContentReplacerType.AddOrModify && assetFileInfo.Replacer == null)
					{
						throw new Exception("Replacer must be non-null when status is Modified!");
					}
					list.Add(new AssetFileInfo
					{
						PathId = assetFileInfo.PathId,
						ByteOffset = assetFileInfo.ByteOffset,
						ByteSize = assetFileInfo.ByteSize,
						TypeIdOrIndex = assetFileInfo.TypeIdOrIndex,
						OldTypeId = assetFileInfo.OldTypeId,
						ScriptTypeIndex = assetFileInfo.ScriptTypeIndex,
						Stripped = assetFileInfo.Stripped,
						Replacer = assetFileInfo.Replacer
					});
				}
			}
			list.Sort((AssetFileInfo i1, AssetFileInfo i2) => i1.PathId.CompareTo(i2.PathId));
			AssetsFileMetadata assetsFileMetadata = new AssetsFileMetadata
			{
				UnityVersion = Metadata.UnityVersion,
				TargetPlatform = Metadata.TargetPlatform,
				TypeTreeEnabled = Metadata.TypeTreeEnabled,
				TypeTreeTypes = Metadata.TypeTreeTypes,
				AssetInfos = list,
				ScriptTypes = Metadata.ScriptTypes,
				Externals = Metadata.Externals,
				RefTypes = Metadata.RefTypes,
				UserInformation = Metadata.UserInformation
			};
			long position = writer.Position;
			assetsFileMetadata.Write(writer, Header.Version);
			int num2 = (int)(writer.Position - position);
			if (writer.Position < 4096)
			{
				while (writer.Position < 4096)
				{
					writer.Write((byte)0);
				}
			}
			else if (writer.Position % 16 == 0)
			{
				writer.Position += 16L;
			}
			else
			{
				writer.Align16();
			}
			long position2 = writer.Position;
			for (int k = 0; k < list.Count; k++)
			{
				AssetFileInfo assetFileInfo2 = list[k];
				long position3 = writer.Position;
				long byteOffset = position3 - position2;
				ContentReplacerType replacerType2 = assetFileInfo2.ReplacerType;
				if (replacerType2 == ContentReplacerType.AddOrModify)
				{
					assetFileInfo2.Replacer.Write(writer);
				}
				else
				{
					Reader.Position = assetFileInfo2.GetAbsoluteByteOffset(this);
					Reader.BaseStream.CopyToCompat(writer.BaseStream, assetFileInfo2.ByteSize);
				}
				assetFileInfo2.ByteOffset = byteOffset;
				assetFileInfo2.ByteSize = (uint)(writer.Position - position3);
				if (k != list.Count - 1)
				{
					writer.Align8();
				}
			}
			long num3 = writer.Position - num;
			AssetsFileHeader assetsFileHeader = new AssetsFileHeader
			{
				MetadataSize = num2,
				FileSize = num3,
				Version = Header.Version,
				DataOffset = position2,
				Endianness = Header.Endianness
			};
			writer.Position = num;
			assetsFileHeader.Write(writer);
			writer.Position = position;
			assetsFileMetadata.Write(writer, Header.Version);
			writer.Position = num + num3;
		}

		public ushort GetScriptIndex(AssetFileInfo info)
		{
			if (Header.Version < 16)
			{
				return info.ScriptTypeIndex;
			}
			return Metadata.TypeTreeTypes[info.TypeIdOrIndex].ScriptTypeIndex;
		}

		public static bool IsAssetsFile(string filePath)
		{
			using AssetsFileReader assetsFileReader = new AssetsFileReader(filePath);
			return IsAssetsFile(assetsFileReader, 0L, assetsFileReader.BaseStream.Length);
		}

		public static bool IsAssetsFile(AssetsFileReader reader, long offset, long length)
		{
			reader.BigEndian = true;
			if (length < 48)
			{
				return false;
			}
			reader.Position = offset;
			string text = reader.ReadStringLength(5);
			if (text == "Unity")
			{
				return false;
			}
			reader.Position = offset + 8;
			int num = reader.ReadInt32();
			if (num > 99)
			{
				return false;
			}
			reader.Position = offset + 20;
			if (num >= 22)
			{
				reader.Position += 28L;
			}
			string text2 = "";
			char c;
			while (reader.Position < reader.BaseStream.Length && (c = (char)reader.ReadByte()) != 0)
			{
				text2 += c;
				if (text2.Length > 255)
				{
					return false;
				}
			}
			string text3 = Regex.Replace(text2, "[a-zA-Z0-9\\.\\n\\-]", "");
			string text4 = Regex.Replace(text2, "[^a-zA-Z0-9\\.\\n\\-]", "");
			return text3 == "" && text4.Length > 0;
		}

		public AssetFileInfo GetAssetInfo(long pathId)
		{
			return Metadata.GetAssetInfo(pathId);
		}

		public void GenerateQuickLookup()
		{
			Metadata.GenerateQuickLookup();
		}

		public List<AssetFileInfo> GetAssetsOfType(int typeId)
		{
			return Metadata.GetAssetsOfType(typeId);
		}

		public List<AssetFileInfo> GetAssetsOfType(AssetClassID typeId)
		{
			return Metadata.GetAssetsOfType(typeId);
		}

		public List<AssetFileInfo> GetAssetsOfType(int typeId, ushort scriptIndex)
		{
			return Metadata.GetAssetsOfType(typeId, scriptIndex);
		}

		public List<AssetFileInfo> GetAssetsOfType(AssetClassID typeId, ushort scriptIndex)
		{
			return Metadata.GetAssetsOfType(typeId, scriptIndex);
		}
	}
	public class AssetsFileExternal
	{
		public string VirtualAssetPathName { get; set; }

		public GUID128 Guid { get; set; }

		public AssetsFileExternalType Type { get; set; }

		public string PathName { get; set; }

		public string OriginalPathName { get; set; }

		public void Read(AssetsFileReader reader)
		{
			VirtualAssetPathName = reader.ReadNullTerminated();
			Guid = new GUID128(reader);
			Type = (AssetsFileExternalType)reader.ReadInt32();
			PathName = reader.ReadNullTerminated();
			OriginalPathName = PathName;
			if (PathName == "resources/unity_builtin_extra")
			{
				PathName = "Resources/unity_builtin_extra";
			}
			else if (PathName == "library/unity default resources" || PathName == "Library/unity default resources")
			{
				PathName = "Resources/unity default resources";
			}
			else if (PathName == "library/unity editor resources" || PathName == "Library/unity editor resources")
			{
				PathName = "Resources/unity editor resources";
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.WriteNullTerminated(VirtualAssetPathName);
			Guid.Write(writer);
			writer.Write((int)Type);
			string text = PathName;
			if ((PathName == "Resources/unity_builtin_extra" || PathName == "Resources/unity default resources" || PathName == "Resources/unity editor resources") && OriginalPathName != string.Empty)
			{
				text = OriginalPathName;
			}
			writer.WriteNullTerminated(text);
		}
	}
	public enum AssetsFileExternalType
	{
		Normal,
		Cached,
		Serialized,
		Meta
	}
	public class AssetsFileHeader
	{
		public long MetadataSize { get; set; }

		public long FileSize { get; set; }

		public uint Version { get; set; }

		public long DataOffset { get; set; }

		public bool Endianness { get; set; }

		public void Read(AssetsFileReader reader)
		{
			reader.BigEndian = true;
			MetadataSize = reader.ReadUInt32();
			FileSize = reader.ReadUInt32();
			Version = reader.ReadUInt32();
			DataOffset = reader.ReadUInt32();
			Endianness = reader.ReadBoolean();
			reader.Position += 3L;
			if (Version >= 22)
			{
				MetadataSize = reader.ReadUInt32();
				FileSize = reader.ReadInt64();
				DataOffset = reader.ReadInt64();
				reader.Position += 8L;
			}
			reader.BigEndian = Endianness;
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.BigEndian = true;
			if (Version >= 22)
			{
				writer.Write(0);
				writer.Write(0);
				writer.Write(Version);
				writer.Write(0);
			}
			else
			{
				writer.Write((uint)MetadataSize);
				writer.Write((uint)FileSize);
				writer.Write(Version);
				writer.Write((uint)DataOffset);
			}
			writer.Write(Endianness);
			writer.Write(new byte[3]);
			if (Version >= 22)
			{
				writer.Write((uint)MetadataSize);
				writer.Write(FileSize);
				writer.Write(DataOffset);
				writer.Write(new byte[8]);
			}
			writer.BigEndian = Endianness;
		}
	}
	public class AssetsFileMetadata
	{
		private Dictionary<long, int> _quickLookup = null;

		public string UnityVersion { get; set; }

		public uint TargetPlatform { get; set; }

		public bool TypeTreeEnabled { get; set; }

		public List<TypeTreeType> TypeTreeTypes { get; set; }

		public IList<AssetFileInfo> AssetInfos { get; set; }

		public List<AssetPPtr> ScriptTypes { get; set; }

		public List<AssetsFileExternal> Externals { get; set; }

		public List<TypeTreeType> RefTypes { get; set; }

		public string UserInformation { get; set; }

		public void Read(AssetsFileReader reader, AssetsFileHeader header)
		{
			Read(reader, header.Version);
		}

		public void Read(AssetsFileReader reader, uint version)
		{
			_quickLookup = null;
			UnityVersion = reader.ReadNullTerminated();
			TargetPlatform = reader.ReadUInt32();
			if (version >= 13)
			{
				TypeTreeEnabled = reader.ReadBoolean();
			}
			int num = reader.ReadInt32();
			TypeTreeTypes = new List<TypeTreeType>(num);
			for (int i = 0; i < num; i++)
			{
				TypeTreeType typeTreeType = new TypeTreeType();
				typeTreeType.Read(reader, version, TypeTreeEnabled, isRefType: false);
				TypeTreeTypes.Add(typeTreeType);
			}
			int num2 = reader.ReadInt32();
			reader.Align();
			AssetInfos = new List<AssetFileInfo>(num2);
			for (int j = 0; j < num2; j++)
			{
				AssetFileInfo assetFileInfo = new AssetFileInfo();
				assetFileInfo.Read(reader, version);
				assetFileInfo.TypeId = assetFileInfo.GetTypeId(this, version);
				AssetInfos.Add(assetFileInfo);
			}
			int num3 = reader.ReadInt32();
			ScriptTypes = new List<AssetPPtr>(num3);
			for (int k = 0; k < num3; k++)
			{
				int fileId = reader.ReadInt32();
				reader.Align();
				long pathId = reader.ReadInt64();
				AssetPPtr item = new AssetPPtr(fileId, pathId);
				ScriptTypes.Add(item);
			}
			int num4 = reader.ReadInt32();
			Externals = new List<AssetsFileExternal>(num4);
			for (int l = 0; l < num4; l++)
			{
				AssetsFileExternal assetsFileExternal = new AssetsFileExternal();
				assetsFileExternal.Read(reader);
				Externals.Add(assetsFileExternal);
			}
			if (version >= 20)
			{
				int num5 = reader.ReadInt32();
				RefTypes = new List<TypeTreeType>(num5);
				for (int m = 0; m < num5; m++)
				{
					TypeTreeType typeTreeType2 = new TypeTreeType();
					typeTreeType2.Read(reader, version, TypeTreeEnabled, isRefType: true);
					RefTypes.Add(typeTreeType2);
				}
			}
			if (version >= 5)
			{
				UserInformation = reader.ReadNullTerminated();
			}
		}

		public void Write(AssetsFileWriter writer, uint version)
		{
			writer.WriteNullTerminated(UnityVersion);
			writer.Write(TargetPlatform);
			if (version >= 13)
			{
				writer.Write(TypeTreeEnabled);
			}
			writer.Write(TypeTreeTypes.Count);
			for (int i = 0; i < TypeTreeTypes.Count; i++)
			{
				TypeTreeTypes[i].Write(writer, version, TypeTreeEnabled);
			}
			writer.Write(AssetInfos.Count);
			writer.Align();
			for (int j = 0; j < AssetInfos.Count; j++)
			{
				AssetInfos[j].Write(writer, version);
			}
			writer.Write(ScriptTypes.Count);
			for (int k = 0; k < ScriptTypes.Count; k++)
			{
				writer.Write(ScriptTypes[k].FileId);
				writer.Align();
				writer.Write(ScriptTypes[k].PathId);
			}
			writer.Write(Externals.Count);
			for (int l = 0; l < Externals.Count; l++)
			{
				Externals[l].Write(writer);
			}
			if (version >= 20)
			{
				writer.Write(RefTypes.Count);
				for (int m = 0; m < RefTypes.Count; m++)
				{
					RefTypes[m].Write(writer, version, TypeTreeEnabled);
				}
			}
			if (version >= 5)
			{
				writer.WriteNullTerminated(UserInformation);
			}
		}

		public AssetFileInfo GetAssetInfo(long pathId)
		{
			if (_quickLookup != null)
			{
				if (_quickLookup.ContainsKey(pathId))
				{
					return AssetInfos[_quickLookup[pathId]];
				}
			}
			else
			{
				for (int i = 0; i < AssetInfos.Count; i++)
				{
					AssetFileInfo assetFileInfo = AssetInfos[i];
					if (assetFileInfo.PathId == pathId)
					{
						return assetFileInfo;
					}
				}
			}
			return null;
		}

		public void AddAssetInfo(AssetFileInfo info)
		{
			if (_quickLookup != null)
			{
				_quickLookup[info.PathId] = AssetInfos.Count;
			}
			AssetInfos.Add(info);
		}

		public bool RemoveAssetInfo(AssetFileInfo info)
		{
			if (_quickLookup != null)
			{
				_quickLookup.Remove(info.PathId);
			}
			return AssetInfos.Remove(info);
		}

		public void GenerateQuickLookup()
		{
			_quickLookup = new Dictionary<long, int>();
			for (int i = 0; i < AssetInfos.Count; i++)
			{
				AssetFileInfo assetFileInfo = AssetInfos[i];
				_quickLookup[assetFileInfo.PathId] = i;
			}
		}

		public List<AssetFileInfo> GetAssetsOfType(int typeId)
		{
			List<AssetFileInfo> list = new List<AssetFileInfo>();
			foreach (AssetFileInfo assetInfo in AssetInfos)
			{
				if (assetInfo.TypeId == typeId)
				{
					list.Add(assetInfo);
				}
			}
			return list;
		}

		public List<AssetFileInfo> GetAssetsOfType(int typeId, ushort scriptIndex)
		{
			List<AssetFileInfo> list = new List<AssetFileInfo>();
			foreach (AssetFileInfo assetInfo in AssetInfos)
			{
				if (scriptIndex != ushort.MaxValue)
				{
					if (assetInfo.TypeId < 0)
					{
						if (assetInfo.ScriptTypeIndex != scriptIndex || (typeId != 114 && (typeId >= 0 || assetInfo.TypeId != typeId)))
						{
							continue;
						}
					}
					else if (assetInfo.TypeId != 114 || FindTypeTreeTypeByID(assetInfo.TypeId, assetInfo.ScriptTypeIndex).ScriptTypeIndex != scriptIndex || typeId != 114)
					{
						continue;
					}
				}
				else if (assetInfo.TypeId != typeId)
				{
					continue;
				}
				list.Add(assetInfo);
			}
			return list;
		}

		public List<AssetFileInfo> GetAssetsOfType(AssetClassID typeId)
		{
			return GetAssetsOfType((int)typeId);
		}

		public List<AssetFileInfo> GetAssetsOfType(AssetClassID typeId, ushort scriptIndex)
		{
			return GetAssetsOfType((int)typeId, scriptIndex);
		}

		public TypeTreeType FindTypeTreeTypeByID(int id)
		{
			foreach (TypeTreeType typeTreeType in TypeTreeTypes)
			{
				if (typeTreeType.TypeId == id)
				{
					return typeTreeType;
				}
			}
			return null;
		}

		public TypeTreeType FindTypeTreeTypeByID(int id, ushort scriptIndex)
		{
			foreach (TypeTreeType typeTreeType in TypeTreeTypes)
			{
				if (typeTreeType.TypeId == id)
				{
					if (typeTreeType.ScriptTypeIndex == scriptIndex)
					{
						return typeTreeType;
					}
					if (id < 0 && typeTreeType.ScriptTypeIndex == ushort.MaxValue)
					{
						return typeTreeType;
					}
				}
			}
			return null;
		}

		public int FindTypeTreeTypeIndexByID(int id, ushort scriptIndex)
		{
			int count = TypeTreeTypes.Count;
			for (int i = 0; i < count; i++)
			{
				TypeTreeType typeTreeType = TypeTreeTypes[i];
				if (typeTreeType.TypeId == id)
				{
					if (typeTreeType.ScriptTypeIndex == scriptIndex)
					{
						return i;
					}
					if (id < 0 && typeTreeType.ScriptTypeIndex == ushort.MaxValue)
					{
						return i;
					}
				}
			}
			return -1;
		}

		public TypeTreeType FindTypeTreeTypeByScriptIndex(ushort scriptIndex)
		{
			foreach (TypeTreeType typeTreeType in TypeTreeTypes)
			{
				if (typeTreeType.ScriptTypeIndex == scriptIndex)
				{
					return typeTreeType;
				}
			}
			return null;
		}

		public TypeTreeType FindTypeTreeTypeByName(string name)
		{
			foreach (TypeTreeType typeTreeType in TypeTreeTypes)
			{
				if (typeTreeType.Nodes.Count == 0 || !(typeTreeType.Nodes[0].GetTypeString(typeTreeType.StringBufferBytes) == name))
				{
					continue;
				}
				return typeTreeType;
			}
			return null;
		}

		public TypeTreeType FindRefTypeByIndex(ushort scriptIndex)
		{
			foreach (TypeTreeType refType in RefTypes)
			{
				if (refType.ScriptTypeIndex == scriptIndex)
				{
					return refType;
				}
			}
			return null;
		}
	}
	public class AssetTypeReference
	{
		public static readonly AssetTypeReference TERMINUS = new AssetTypeReference("Terminus", "UnityEngine.DMAT", "FAKE_ASM");

		public string ClassName { get; set; }

		public string Namespace { get; set; }

		public string AsmName { get; set; }

		public AssetTypeReference()
		{
		}

		public AssetTypeReference(string className, string nameSpace, string asmName)
		{
			ClassName = className;
			Namespace = nameSpace;
			AsmName = asmName;
		}

		public void ReadMetadata(AssetsFileReader reader)
		{
			ClassName = reader.ReadNullTerminated();
			Namespace = reader.ReadNullTerminated();
			AsmName = reader.ReadNullTerminated();
		}

		public void ReadAsset(AssetsFileReader reader)
		{
			ClassName = reader.ReadCountStringInt32();
			reader.Align();
			Namespace = reader.ReadCountStringInt32();
			reader.Align();
			AsmName = reader.ReadCountStringInt32();
			reader.Align();
		}

		public void WriteMetadata(AssetsFileWriter writer)
		{
			writer.WriteNullTerminated(ClassName);
			writer.WriteNullTerminated(Namespace);
			writer.WriteNullTerminated(AsmName);
		}

		public void WriteAsset(AssetsFileWriter writer)
		{
			writer.WriteCountStringInt32(ClassName);
			writer.Align();
			writer.WriteCountStringInt32(Namespace);
			writer.Align();
			writer.WriteCountStringInt32(AsmName);
			writer.Align();
		}

		public override bool Equals(object obj)
		{
			if (!(obj is AssetTypeReference assetTypeReference))
			{
				return false;
			}
			return ClassName == assetTypeReference.ClassName && Namespace == assetTypeReference.Namespace && AsmName == assetTypeReference.AsmName;
		}

		public override int GetHashCode()
		{
			int num = 17;
			num = num * 23 + ClassName.GetHashCode();
			num = num * 23 + Namespace.GetHashCode();
			return num * 23 + AsmName.GetHashCode();
		}
	}
	public struct GUID128
	{
		private const string HexToLiteral = "0123456789abcdef";

		public uint data0;

		public uint data1;

		public uint data2;

		public uint data3;

		public bool IsEmpty => data0 == 0 && data1 == 0 && data2 == 0 && data3 == 0;

		public uint this[int i]
		{
			get
			{
				if (1 == 0)
				{
				}
				uint result = i switch
				{
					0 => data0, 
					1 => data1, 
					2 => data2, 
					3 => data3, 
					_ => throw new IndexOutOfRangeException(), 
				};
				if (1 == 0)
				{
				}
				return result;
			}
			set
			{
				switch (i)
				{
				case 0:
					data0 = value;
					break;
				case 1:
					data1 = value;
					break;
				case 2:
					data2 = value;
					break;
				case 3:
					data3 = value;
					break;
				default:
					throw new IndexOutOfRangeException();
				}
			}
		}

		public GUID128(AssetsFileReader reader)
		{
			this = default(GUID128);
			Read(reader);
		}

		public void Read(AssetsFileReader reader)
		{
			data0 = reader.ReadUInt32();
			data1 = reader.ReadUInt32();
			data2 = reader.ReadUInt32();
			data3 = reader.ReadUInt32();
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(data0);
			writer.Write(data1);
			writer.Write(data2);
			writer.Write(data3);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder(32);
			for (int num = 3; num >= 0; num--)
			{
				for (int num2 = 7; num2 >= 0; num2--)
				{
					uint num3 = this[num];
					num3 >>= num2 * 4;
					num3 &= 0xFu;
					stringBuilder.Insert(0, "0123456789abcdef"[(int)num3]);
				}
			}
			return stringBuilder.ToString();
		}

		public static bool TryParse(string str, out GUID128 guid)
		{
			guid = default(GUID128);
			if (str.Length != 32)
			{
				return false;
			}
			for (int i = 0; i < 4; i++)
			{
				uint num = 0u;
				for (int num2 = 7; num2 >= 0; num2--)
				{
					uint num3 = LiteralToHex(str[i * 8 + num2]);
					if (num3 == uint.MaxValue)
					{
						return false;
					}
					num |= num3 << num2 * 4;
				}
				guid[i] = num;
			}
			return true;
		}

		private static uint LiteralToHex(char c)
		{
			if (1 == 0)
			{
			}
			uint result = c switch
			{
				'0' => 0u, 
				'1' => 1u, 
				'2' => 2u, 
				'3' => 3u, 
				'4' => 4u, 
				'5' => 5u, 
				'6' => 6u, 
				'7' => 7u, 
				'8' => 8u, 
				'9' => 9u, 
				'a' => 10u, 
				'b' => 11u, 
				'c' => 12u, 
				'd' => 13u, 
				'e' => 14u, 
				'f' => 15u, 
				_ => uint.MaxValue, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public struct Hash128
	{
		public byte[] data;

		public Hash128(byte[] data)
		{
			this.data = data;
		}

		public Hash128(AssetsFileReader reader)
		{
			data = reader.ReadBytes(16);
		}

		public bool IsZero()
		{
			if (data == null)
			{
				return true;
			}
			for (int i = 0; i < data.Length; i++)
			{
				if (data[i] != 0)
				{
					return false;
				}
			}
			return true;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder(data.Length * 2);
			byte[] array = data;
			foreach (byte b in array)
			{
				stringBuilder.AppendFormat("{0:x2}", b);
			}
			return stringBuilder.ToString();
		}

		public static Hash128 NewBlankHash()
		{
			Hash128 result = default(Hash128);
			result.data = new byte[16];
			return result;
		}
	}
	public class TypeTreeNode
	{
		public ushort Version { get; set; }

		public byte Level { get; set; }

		public TypeTreeNodeFlags TypeFlags { get; set; }

		public uint TypeStrOffset { get; set; }

		public uint NameStrOffset { get; set; }

		public int ByteSize { get; set; }

		public uint Index { get; set; }

		public uint MetaFlags { get; set; }

		public ulong RefTypeHash { get; set; }

		public void Read(AssetsFileReader reader, uint version)
		{
			Version = reader.ReadUInt16();
			Level = reader.ReadByte();
			TypeFlags = (TypeTreeNodeFlags)reader.ReadByte();
			TypeStrOffset = reader.ReadUInt32();
			NameStrOffset = reader.ReadUInt32();
			ByteSize = reader.ReadInt32();
			Index = reader.ReadUInt32();
			MetaFlags = reader.ReadUInt32();
			if (version >= 18)
			{
				RefTypeHash = reader.ReadUInt64();
			}
		}

		public void Write(AssetsFileWriter writer, uint version)
		{
			writer.Write(Version);
			writer.Write(Level);
			writer.Write((byte)TypeFlags);
			writer.Write(TypeStrOffset);
			writer.Write(NameStrOffset);
			writer.Write(ByteSize);
			writer.Write(Index);
			writer.Write(MetaFlags);
			if (version >= 18)
			{
				writer.Write(RefTypeHash);
			}
		}

		public string GetTypeString(byte[] stringTable, byte[] commonStringTable = null)
		{
			return ReadStringTableString(stringTable, commonStringTable ?? TypeTreeType.COMMON_STRING_TABLE, TypeStrOffset);
		}

		public string GetNameString(byte[] stringTable, byte[] commonStringTable = null)
		{
			return ReadStringTableString(stringTable, commonStringTable ?? TypeTreeType.COMMON_STRING_TABLE, NameStrOffset);
		}

		private string ReadStringTableString(byte[] stringTable, byte[] commonStringTable, uint offset)
		{
			if ((offset & 0x80000000u) != 0)
			{
				offset &= 0x7FFFFFFFu;
				stringTable = commonStringTable;
			}
			using MemoryStream memoryStream = new MemoryStream();
			int num = (int)offset;
			byte value;
			while ((value = stringTable[num]) != 0)
			{
				memoryStream.WriteByte(value);
				num++;
			}
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}
	}
	[Flags]
	public enum TypeTreeNodeFlags
	{
		None = 0,
		Array = 1,
		Ref = 2,
		Registry = 4,
		ArrayOfRefs = 8
	}
	public class TypeTreeType
	{
		public static readonly byte[] COMMON_STRING_TABLE = Encoding.UTF8.GetBytes("AABB\0AnimationClip\0AnimationCurve\0AnimationState\0Array\0Base\0BitField\0bitset\0bool\0char\0ColorRGBA\0Component\0data\0deque\0double\0dynamic_array\0FastPropertyName\0first\0float\0Font\0GameObject\0Generic Mono\0GradientNEW\0GUID\0GUIStyle\0int\0list\0long long\0map\0Matrix4x4f\0MdFour\0MonoBehaviour\0MonoScript\0m_ByteSize\0m_Curve\0m_EditorClassIdentifier\0m_EditorHideFlags\0m_Enabled\0m_ExtensionPtr\0m_GameObject\0m_Index\0m_IsArray\0m_IsStatic\0m_MetaFlag\0m_Name\0m_ObjectHideFlags\0m_PrefabInternal\0m_PrefabParentObject\0m_Script\0m_StaticEditorFlags\0m_Type\0m_Version\0Object\0pair\0PPtr<Component>\0PPtr<GameObject>\0PPtr<Material>\0PPtr<MonoBehaviour>\0PPtr<MonoScript>\0PPtr<Object>\0PPtr<Prefab>\0PPtr<Sprite>\0PPtr<TextAsset>\0PPtr<Texture>\0PPtr<Texture2D>\0PPtr<Transform>\0Prefab\0Quaternionf\0Rectf\0RectInt\0RectOffset\0second\0set\0short\0size\0SInt16\0SInt32\0SInt64\0SInt8\0staticvector\0string\0TextAsset\0TextMesh\0Texture\0Texture2D\0Transform\0TypelessData\0UInt16\0UInt32\0UInt64\0UInt8\0unsigned int\0unsigned long long\0unsigned short\0vector\0Vector2f\0Vector3f\0Vector4f\0m_ScriptingClassIdentifier\0Gradient\0Type*\0int2_storage\0int3_storage\0BoundsInt\0m_CorrespondingSourceObject\0m_PrefabInstance\0m_PrefabAsset\0FileSize\0Hash128\0");

		public int TypeId { get; set; }

		public bool IsStrippedType { get; set; }

		public ushort ScriptTypeIndex { get; set; }

		public Hash128 ScriptIdHash { get; set; }

		public Hash128 TypeHash { get; set; }

		public List<TypeTreeNode> Nodes { get; set; }

		public byte[] StringBufferBytes { get; set; }

		public bool IsRefType { get; set; }

		public int[] TypeDependencies { get; set; }

		public AssetTypeReference TypeReference { get; set; }

		public string StringBuffer
		{
			get
			{
				return Encoding.UTF8.GetString(StringBufferBytes);
			}
			set
			{
				StringBufferBytes = Encoding.UTF8.GetBytes(value);
			}
		}

		public void Read(AssetsFileReader reader, uint version, bool hasTypeTree, bool isRefType)
		{
			TypeId = reader.ReadInt32();
			if (version >= 16)
			{
				IsStrippedType = reader.ReadBoolean();
			}
			if (version >= 17)
			{
				ScriptTypeIndex = reader.ReadUInt16();
			}
			else
			{
				ScriptTypeIndex = ushort.MaxValue;
			}
			if ((version < 17 && TypeId < 0) || (version >= 17 && TypeId == 114) || (isRefType && ScriptTypeIndex != ushort.MaxValue))
			{
				ScriptIdHash = new Hash128(reader);
			}
			TypeHash = new Hash128(reader);
			IsRefType = isRefType;
			if (!hasTypeTree)
			{
				return;
			}
			int num = reader.ReadInt32();
			int count = reader.ReadInt32();
			Nodes = new List<TypeTreeNode>(num);
			for (int i = 0; i < num; i++)
			{
				TypeTreeNode typeTreeNode = new TypeTreeNode();
				typeTreeNode.Read(reader, version);
				Nodes.Add(typeTreeNode);
			}
			StringBufferBytes = reader.ReadBytes(count);
			if (version < 21)
			{
				return;
			}
			if (!isRefType)
			{
				int num2 = reader.ReadInt32();
				TypeDependencies = new int[num2];
				for (int j = 0; j < num2; j++)
				{
					TypeDependencies[j] = reader.ReadInt32();
				}
			}
			else
			{
				TypeReference = new AssetTypeReference();
				TypeReference.ReadMetadata(reader);
			}
		}

		public void Write(AssetsFileWriter writer, uint version, bool hasTypeTree)
		{
			writer.Write(TypeId);
			if (version >= 16)
			{
				writer.Write(IsStrippedType);
			}
			if (version >= 17)
			{
				writer.Write(ScriptTypeIndex);
			}
			if ((version < 17 && TypeId < 0) || (version >= 17 && TypeId == 114) || (IsRefType && ScriptTypeIndex != ushort.MaxValue))
			{
				writer.Write(ScriptIdHash.data);
			}
			writer.Write(TypeHash.data);
			if (!hasTypeTree)
			{
				return;
			}
			writer.Write(Nodes.Count);
			writer.Write(StringBufferBytes.Length);
			for (int i = 0; i < Nodes.Count; i++)
			{
				Nodes[i].Write(writer, version);
			}
			writer.Write(StringBufferBytes);
			if (version < 21)
			{
				return;
			}
			if (!IsRefType)
			{
				writer.Write(TypeDependencies.Length);
				for (int j = 0; j < TypeDependencies.Length; j++)
				{
					writer.Write(TypeDependencies[j]);
				}
			}
			else
			{
				TypeReference.WriteMetadata(writer);
			}
		}
	}
	public struct AssetTypeArrayInfo
	{
		public int size;

		public AssetTypeArrayInfo(int size)
		{
			this.size = size;
		}
	}
	public class AssetTypeReferencedObject
	{
		public long rid;

		public AssetTypeReference type;

		public AssetTypeValueField data;
	}
	public class AssetTypeTemplateField
	{
		public string Name { get; set; }

		public string Type { get; set; }

		public AssetValueType ValueType { get; set; }

		public bool IsArray { get; set; }

		public bool IsAligned { get; set; }

		public bool HasValue { get; set; }

		public List<AssetTypeTemplateField> Children { get; set; }

		public void FromTypeTree(TypeTreeType typeTreeType)
		{
			int fieldIndex = 0;
			FromTypeTree(typeTreeType, ref fieldIndex);
		}

		private void FromTypeTree(TypeTreeType typeTreeType, ref int fieldIndex)
		{
			TypeTreeNode typeTreeNode = typeTreeType.Nodes[fieldIndex];
			Name = typeTreeNode.GetNameString(typeTreeType.StringBufferBytes);
			Type = typeTreeNode.GetTypeString(typeTreeType.StringBufferBytes);
			ValueType = AssetTypeValueField.GetValueTypeByTypeName(Type);
			IsArray = Net35Polyfill.HasFlag(typeTreeNode.TypeFlags, TypeTreeNodeFlags.Array);
			IsAligned = (typeTreeNode.MetaFlags & 0x4000) != 0;
			HasValue = ValueType != AssetValueType.None;
			Children = new List<AssetTypeTemplateField>();
			fieldIndex++;
			while (fieldIndex < typeTreeType.Nodes.Count)
			{
				TypeTreeNode typeTreeNode2 = typeTreeType.Nodes[fieldIndex];
				if (typeTreeNode2.Level <= typeTreeNode.Level)
				{
					fieldIndex--;
					break;
				}
				AssetTypeTemplateField assetTypeTemplateField = new AssetTypeTemplateField();
				assetTypeTemplateField.FromTypeTree(typeTreeType, ref fieldIndex);
				Children.Add(assetTypeTemplateField);
				fieldIndex++;
			}
			if (ValueType == AssetValueType.String && !Children[0].IsArray && Children[0].ValueType != 0)
			{
				Type = Children[0].Type;
				ValueType = Children[0].ValueType;
				Children.Clear();
			}
			if (IsArray)
			{
				ValueType = ((Children[1].ValueType == AssetValueType.UInt8) ? AssetValueType.ByteArray : AssetValueType.Array);
			}
			Children.TrimExcess();
		}

		public void FromClassDatabase(ClassDatabaseFile cldbFile, ClassDatabaseType cldbType, bool preferEditor = false)
		{
			if (cldbType.EditorRootNode == null && cldbType.ReleaseRootNode == null)
			{
				throw new Exception("No root nodes were found!");
			}
			ClassDatabaseTypeNode preferredNode = cldbType.GetPreferredNode(preferEditor);
			FromClassDatabase(cldbFile.StringTable, preferredNode);
		}

		private void FromClassDatabase(ClassDatabaseStringTable strTable, ClassDatabaseTypeNode node)
		{
			Name = strTable.GetString(node.FieldName);
			Type = strTable.GetString(node.TypeName);
			if (Type == "SInt32")
			{
				Type = "int";
			}
			else if (Type == "UInt32")
			{
				Type = "unsigned int";
			}
			ValueType = AssetTypeValueField.GetValueTypeByTypeName(Type);
			IsArray = node.TypeFlags == 1;
			IsAligned = (node.MetaFlag & 0x4000) != 0;
			HasValue = ValueType != AssetValueType.None;
			Children = new List<AssetTypeTemplateField>(node.Children.Count);
			foreach (ClassDatabaseTypeNode child in node.Children)
			{
				AssetTypeTemplateField assetTypeTemplateField = new AssetTypeTemplateField();
				assetTypeTemplateField.FromClassDatabase(strTable, child);
				Children.Add(assetTypeTemplateField);
			}
			if (ValueType == AssetValueType.String && !Children[0].IsArray && Children[0].ValueType != 0)
			{
				Type = Children[0].Type;
				ValueType = Children[0].ValueType;
				Children.Clear();
				Children.TrimExcess();
			}
			if (IsArray)
			{
				ValueType = ((Children[1].ValueType == AssetValueType.UInt8) ? AssetValueType.ByteArray : AssetValueType.Array);
			}
		}

		public AssetTypeValueField MakeValue(AssetsFileReader reader, RefTypeManager refMan = null)
		{
			AssetTypeValueField valueField = new AssetTypeValueField
			{
				TemplateField = this
			};
			return ReadType(reader, valueField, refMan);
		}

		public AssetTypeValueField MakeValue(AssetsFileReader reader, long position, RefTypeManager refMan = null)
		{
			reader.Position = position;
			return MakeValue(reader, refMan);
		}

		public AssetTypeValueField ReadType(AssetsFileReader reader, AssetTypeValueField valueField, RefTypeManager refMan)
		{
			if (valueField.TemplateField.IsArray)
			{
				int count = valueField.TemplateField.Children.Count;
				if (count != 2)
				{
					throw new Exception($"Expected array to have two children, found {count} instead!");
				}
				AssetValueType valueType = valueField.TemplateField.Children[0].ValueType;
				if (valueType != AssetValueType.Int32 && valueType != AssetValueType.UInt32)
				{
					throw new Exception($"Expected int array size type, found {valueType} instead!");
				}
				if (valueField.TemplateField.ValueType == AssetValueType.ByteArray)
				{
					valueField.Children = new List<AssetTypeValueField>(0);
					int count2 = reader.ReadInt32();
					byte[] value = reader.ReadBytes(count2);
					if (valueField.TemplateField.IsAligned)
					{
						reader.Align();
					}
					valueField.Value = new AssetTypeValue(AssetValueType.ByteArray, value);
				}
				else
				{
					int num = reader.ReadInt32();
					valueField.Children = new List<AssetTypeValueField>(num);
					for (int i = 0; i < num; i++)
					{
						AssetTypeValueField assetTypeValueField = new AssetTypeValueField();
						assetTypeValueField.TemplateField = valueField.TemplateField.Children[1];
						valueField.Children.Add(ReadType(reader, assetTypeValueField, refMan));
					}
					valueField.Children.TrimExcess();
					if (valueField.TemplateField.IsAligned)
					{
						reader.Align();
					}
					AssetTypeArrayInfo assetTypeArrayInfo = default(AssetTypeArrayInfo);
					assetTypeArrayInfo.size = num;
					AssetTypeArrayInfo assetTypeArrayInfo2 = assetTypeArrayInfo;
					valueField.Value = new AssetTypeValue(AssetValueType.Array, assetTypeArrayInfo2);
				}
			}
			else
			{
				switch (valueField.TemplateField.ValueType)
				{
				case AssetValueType.None:
				{
					int count5 = valueField.TemplateField.Children.Count;
					valueField.Children = new List<AssetTypeValueField>(count5);
					for (int k = 0; k < count5; k++)
					{
						AssetTypeValueField assetTypeValueField2 = new AssetTypeValueField();
						assetTypeValueField2.TemplateField = valueField.TemplateField.Children[k];
						valueField.Children.Add(ReadType(reader, assetTypeValueField2, refMan));
					}
					valueField.Children.TrimExcess();
					valueField.Value = null;
					if (valueField.TemplateField.IsAligned)
					{
						reader.Align();
					}
					break;
				}
				case AssetValueType.String:
				{
					valueField.Children = new List<AssetTypeValueField>(0);
					int count3 = reader.ReadInt32();
					valueField.Value = new AssetTypeValue(reader.ReadBytes(count3), asString: true);
					reader.Align();
					break;
				}
				case AssetValueType.ManagedReferencesRegistry:
				{
					if (refMan == null)
					{
						throw new Exception("refMan MUST be set to deserialize objects with ref types!");
					}
					valueField.Children = new List<AssetTypeValueField>(0);
					ManagedReferencesRegistry managedReferencesRegistry = new ManagedReferencesRegistry();
					valueField.Value = new AssetTypeValue(managedReferencesRegistry);
					int count4 = valueField.TemplateField.Children.Count;
					if (count4 != 2)
					{
						throw new Exception($"Expected ManagedReferencesRegistry to have two children, found {count4} instead!");
					}
					managedReferencesRegistry.version = reader.ReadInt32();
					managedReferencesRegistry.references = new List<AssetTypeReferencedObject>(0);
					if (managedReferencesRegistry.version == 1)
					{
						while (true)
						{
							AssetTypeReferencedObject assetTypeReferencedObject = MakeReferencedObject(reader, managedReferencesRegistry.version, managedReferencesRegistry.references.Count, refMan);
							if (assetTypeReferencedObject.type.Equals(AssetTypeReference.TERMINUS))
							{
								break;
							}
							managedReferencesRegistry.references.Add(assetTypeReferencedObject);
						}
					}
					else
					{
						int num2 = reader.ReadInt32();
						for (int j = 0; j < num2; j++)
						{
							AssetTypeReferencedObject item = MakeReferencedObject(reader, managedReferencesRegistry.version, j, refMan);
							managedReferencesRegistry.references.Add(item);
						}
					}
					break;
				}
				default:
					if (valueField.TemplateField.Children.Count == 0)
					{
						valueField.Children = new List<AssetTypeValueField>(0);
						switch (valueField.TemplateField.ValueType)
						{
						case AssetValueType.Int8:
							valueField.Value = new AssetTypeValue(reader.ReadSByte());
							break;
						case AssetValueType.UInt8:
							valueField.Value = new AssetTypeValue(reader.ReadByte());
							break;
						case AssetValueType.Bool:
							valueField.Value = new AssetTypeValue(reader.ReadBoolean());
							break;
						case AssetValueType.Int16:
							valueField.Value = new AssetTypeValue(reader.ReadInt16());
							break;
						case AssetValueType.UInt16:
							valueField.Value = new AssetTypeValue(reader.ReadUInt16());
							break;
						case AssetValueType.Int32:
							valueField.Value = new AssetTypeValue(reader.ReadInt32());
							break;
						case AssetValueType.UInt32:
							valueField.Value = new AssetTypeValue(reader.ReadUInt32());
							break;
						case AssetValueType.Int64:
							valueField.Value = new AssetTypeValue(reader.ReadInt64());
							break;
						case AssetValueType.UInt64:
							valueField.Value = new AssetTypeValue(reader.ReadUInt64());
							break;
						case AssetValueType.Float:
							valueField.Value = new AssetTypeValue(reader.ReadSingle());
							break;
						case AssetValueType.Double:
							valueField.Value = new AssetTypeValue(reader.ReadDouble());
							break;
						}
						if (valueField.TemplateField.IsAligned)
						{
							reader.Align();
						}
					}
					else if (valueField.TemplateField.ValueType != 0)
					{
						throw new Exception("Cannot read value of field with children!");
					}
					break;
				}
			}
			return valueField;
		}

		public AssetTypeTemplateField Clone()
		{
			return new AssetTypeTemplateField
			{
				Name = Name,
				Type = Type,
				ValueType = ValueType,
				IsArray = IsArray,
				IsAligned = IsAligned,
				HasValue = HasValue,
				Children = Children.Select((AssetTypeTemplateField c) => c.Clone()).ToList()
			};
		}

		private AssetTypeReferencedObject MakeReferencedObject(AssetsFileReader reader, int registryVersion, int referenceIndex, RefTypeManager refMan)
		{
			AssetTypeReferencedObject assetTypeReferencedObject = new AssetTypeReferencedObject();
			if (registryVersion == 1)
			{
				assetTypeReferencedObject.rid = referenceIndex;
			}
			else
			{
				assetTypeReferencedObject.rid = reader.ReadInt64();
			}
			AssetTypeReference assetTypeReference = new AssetTypeReference();
			assetTypeReference.ReadAsset(reader);
			assetTypeReferencedObject.type = assetTypeReference;
			AssetTypeTemplateField templateField = refMan.GetTemplateField(assetTypeReference);
			if (templateField != null)
			{
				assetTypeReferencedObject.data = new AssetTypeValueField
				{
					TemplateField = templateField
				};
				assetTypeReferencedObject.data = ReadType(reader, assetTypeReferencedObject.data, refMan);
			}
			else
			{
				assetTypeReferencedObject.data = AssetTypeValueField.DUMMY_FIELD;
			}
			return assetTypeReferencedObject;
		}

		public override string ToString()
		{
			return Type + " " + Name;
		}
	}
	public class AssetTypeValue
	{
		public AssetValueType ValueType { get; set; }

		private object Value { get; set; }

		public bool AsBool
		{
			get
			{
				if (Value is bool result)
				{
					return result;
				}
				if (Value is byte b)
				{
					return b == 1;
				}
				return false;
			}
			set
			{
				Value = value;
			}
		}

		public sbyte AsSByte
		{
			get
			{
				if (Value is sbyte result)
				{
					return result;
				}
				return (sbyte)Convert.ChangeType(Value, typeof(sbyte));
			}
			set
			{
				Value = value;
			}
		}

		public byte AsByte
		{
			get
			{
				if (Value is byte result)
				{
					return result;
				}
				return (byte)Convert.ChangeType(Value, typeof(byte));
			}
			set
			{
				Value = value;
			}
		}

		public short AsShort
		{
			get
			{
				if (Value is short result)
				{
					return result;
				}
				return (short)Convert.ChangeType(Value, typeof(short));
			}
			set
			{
				Value = value;
			}
		}

		public ushort AsUShort
		{
			get
			{
				if (Value is ushort result)
				{
					return result;
				}
				return (ushort)Convert.ChangeType(Value, typeof(ushort));
			}
			set
			{
				Value = value;
			}
		}

		public int AsInt
		{
			get
			{
				if (Value is int result)
				{
					return result;
				}
				return (int)Convert.ChangeType(Value, typeof(int));
			}
			set
			{
				Value = value;
			}
		}

		public uint AsUInt
		{
			get
			{
				if (Value is uint result)
				{
					return result;
				}
				return (uint)Convert.ChangeType(Value, typeof(uint));
			}
			set
			{
				Value = value;
			}
		}

		public long AsLong
		{
			get
			{
				if (Value is long result)
				{
					return result;
				}
				return (long)Convert.ChangeType(Value, typeof(long));
			}
			set
			{
				Value = value;
			}
		}

		public ulong AsULong
		{
			get
			{
				if (Value is ulong result)
				{
					return result;
				}
				return (ulong)Convert.ChangeType(Value, typeof(ulong));
			}
			set
			{
				Value = value;
			}
		}

		public float AsFloat
		{
			get
			{
				if (Value is float result)
				{
					return result;
				}
				return (float)Convert.ChangeType(Value, typeof(float));
			}
			set
			{
				Value = value;
			}
		}

		public double AsDouble
		{
			get
			{
				if (Value is double result)
				{
					return result;
				}
				return (double)Convert.ChangeType(Value, typeof(double));
			}
			set
			{
				Value = value;
			}
		}

		public string AsString
		{
			get
			{
				if (ValueType == AssetValueType.String)
				{
					return Encoding.UTF8.GetString((byte[])Value);
				}
				if (ValueType == AssetValueType.Bool)
				{
					return ((bool)Value) ? "true" : "false";
				}
				if (ValueType == AssetValueType.ByteArray)
				{
					return SimpleHexDump((byte[])Value);
				}
				return Value.ToString();
			}
			set
			{
				Value = Encoding.UTF8.GetBytes(value);
			}
		}

		public AssetTypeArrayInfo AsArray
		{
			get
			{
				return (AssetTypeArrayInfo)Value;
			}
			set
			{
				Value = value;
			}
		}

		public byte[] AsByteArray
		{
			get
			{
				return (byte[])Value;
			}
			set
			{
				Value = value;
			}
		}

		public ManagedReferencesRegistry AsManagedReferencesRegistry
		{
			get
			{
				return (ManagedReferencesRegistry)Value;
			}
			set
			{
				Value = value;
			}
		}

		public object AsObject
		{
			get
			{
				return Value;
			}
			set
			{
				if (value is string s)
				{
					Value = Encoding.UTF8.GetBytes(s);
				}
				else
				{
					Value = value;
				}
			}
		}

		public AssetTypeValue(bool value)
		{
			ValueType = AssetValueType.Bool;
			Value = value;
		}

		public AssetTypeValue(sbyte value)
		{
			ValueType = AssetValueType.Int8;
			Value = value;
		}

		public AssetTypeValue(byte value)
		{
			ValueType = AssetValueType.UInt8;
			Value = value;
		}

		public AssetTypeValue(short value)
		{
			ValueType = AssetValueType.Int16;
			Value = value;
		}

		public AssetTypeValue(ushort value)
		{
			ValueType = AssetValueType.UInt16;
			Value = value;
		}

		public AssetTypeValue(int value)
		{
			ValueType = AssetValueType.Int32;
			Value = value;
		}

		public AssetTypeValue(uint value)
		{
			ValueType = AssetValueType.UInt32;
			Value = value;
		}

		public AssetTypeValue(long value)
		{
			ValueType = AssetValueType.Int64;
			Value = value;
		}

		public AssetTypeValue(ulong value)
		{
			ValueType = AssetValueType.UInt64;
			Value = value;
		}

		public AssetTypeValue(float value)
		{
			ValueType = AssetValueType.Float;
			Value = value;
		}

		public AssetTypeValue(double value)
		{
			ValueType = AssetValueType.Double;
			Value = value;
		}

		public AssetTypeValue(string value)
		{
			ValueType = AssetValueType.String;
			Value = Encoding.UTF8.GetBytes(value);
		}

		public AssetTypeValue(byte[] value, bool asString)
		{
			ValueType = (asString ? AssetValueType.String : AssetValueType.ByteArray);
			Value = value;
		}

		public AssetTypeValue(ManagedReferencesRegistry value)
		{
			ValueType = AssetValueType.ManagedReferencesRegistry;
			Value = value;
		}

		public AssetTypeValue(AssetValueType valueType, object value = null)
		{
			ValueType = valueType;
			if (value is string s)
			{
				Value = Encoding.UTF8.GetBytes(s);
			}
			else
			{
				Value = value;
			}
		}

		public override string ToString()
		{
			return AsString;
		}

		private string SimpleHexDump(byte[] byteArray)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (byteArray.Length == 0)
			{
				return string.Empty;
			}
			int i;
			for (i = 0; i < byteArray.Length - 1; i++)
			{
				stringBuilder.Append(byteArray[i].ToString("x2"));
				stringBuilder.Append(" ");
			}
			stringBuilder.Append(byteArray[i].ToString("x2"));
			return stringBuilder.ToString();
		}
	}
	public class AssetTypeValueField : IEnumerable<AssetTypeValueField>, IEnumerable
	{
		public static readonly AssetTypeValueField DUMMY_FIELD = new AssetTypeValueField
		{
			TemplateField = new AssetTypeTemplateField
			{
				Name = "DUMMY",
				HasValue = false,
				IsAligned = false,
				IsArray = false,
				Type = "DUMMY",
				ValueType = AssetValueType.None,
				Children = new List<AssetTypeTemplateField>(0)
			},
			Value = null,
			IsDummy = true,
			Children = new List<AssetTypeValueField>(0)
		};

		public AssetTypeTemplateField TemplateField { get; set; }

		public AssetTypeValue Value { get; set; }

		public List<AssetTypeValueField> Children { get; set; }

		public bool IsDummy { get; set; }

		public AssetTypeValueField this[string name]
		{
			get
			{
				if (IsDummy)
				{
					throw new DummyFieldAccessException("Cannot access fields of a dummy field!");
				}
				if (name.Contains("."))
				{
					string[] array = name.Split('.');
					AssetTypeValueField assetTypeValueField = this;
					string[] array2 = array;
					foreach (string text in array2)
					{
						bool flag = false;
						foreach (AssetTypeValueField child in assetTypeValueField.Children)
						{
							if (child.TemplateField.Name == text)
							{
								flag = true;
								assetTypeValueField = child;
								break;
							}
						}
						if (!flag)
						{
							return DUMMY_FIELD;
						}
					}
					return assetTypeValueField;
				}
				foreach (AssetTypeValueField child2 in Children)
				{
					if (child2.TemplateField.Name == name)
					{
						return child2;
					}
				}
				return DUMMY_FIELD;
			}
		}

		public AssetTypeValueField this[int index]
		{
			get
			{
				if (IsDummy)
				{
					throw new DummyFieldAccessException("Cannot access fields of a dummy field!");
				}
				return Children[index];
			}
		}

		public bool AsBool
		{
			get
			{
				return Value.AsBool;
			}
			set
			{
				Value.AsBool = value;
			}
		}

		public sbyte AsSByte
		{
			get
			{
				return Value.AsSByte;
			}
			set
			{
				Value.AsSByte = value;
			}
		}

		public byte AsByte
		{
			get
			{
				return Value.AsByte;
			}
			set
			{
				Value.AsByte = value;
			}
		}

		public short AsShort
		{
			get
			{
				return Value.AsShort;
			}
			set
			{
				Value.AsShort = value;
			}
		}

		public ushort AsUShort
		{
			get
			{
				return Value.AsUShort;
			}
			set
			{
				Value.AsUShort = value;
			}
		}

		public int AsInt
		{
			get
			{
				return Value.AsInt;
			}
			set
			{
				Value.AsInt = value;
			}
		}

		public uint AsUInt
		{
			get
			{
				return Value.AsUInt;
			}
			set
			{
				Value.AsUInt = value;
			}
		}

		public long AsLong
		{
			get
			{
				return Value.AsLong;
			}
			set
			{
				Value.AsLong = value;
			}
		}

		public ulong AsULong
		{
			get
			{
				return Value.AsULong;
			}
			set
			{
				Value.AsULong = value;
			}
		}

		public float AsFloat
		{
			get
			{
				return Value.AsFloat;
			}
			set
			{
				Value.AsFloat = value;
			}
		}

		public double AsDouble
		{
			get
			{
				return Value.AsDouble;
			}
			set
			{
				Value.AsDouble = value;
			}
		}

		public string AsString
		{
			get
			{
				return Value.AsString;
			}
			set
			{
				Value.AsString = value;
			}
		}

		public object AsObject
		{
			get
			{
				return Value.AsObject;
			}
			set
			{
				Value.AsObject = value;
			}
		}

		public AssetTypeArrayInfo AsArray
		{
			get
			{
				return Value.AsArray;
			}
			set
			{
				Value.AsArray = value;
			}
		}

		public byte[] AsByteArray
		{
			get
			{
				return Value.AsByteArray;
			}
			set
			{
				Value.AsByteArray = value;
			}
		}

		public ManagedReferencesRegistry AsManagedReferencesRegistry
		{
			get
			{
				return Value.AsManagedReferencesRegistry;
			}
			set
			{
				Value.AsManagedReferencesRegistry = value;
			}
		}

		public string TypeName => TemplateField.Type;

		public string FieldName => TemplateField.Name;

		public void Read(AssetTypeValue value, AssetTypeTemplateField templateField, List<AssetTypeValueField> children)
		{
			Value = value;
			TemplateField = templateField;
			Children = children;
			IsDummy = false;
		}

		public AssetTypeValueField Get(string name)
		{
			return this[name];
		}

		public AssetTypeValueField Get(int index)
		{
			return this[index];
		}

		public static AssetValueType GetValueTypeByTypeName(string type)
		{
			switch (type)
			{
			case "string":
				return AssetValueType.String;
			case "SInt8":
			case "char":
				return AssetValueType.Int8;
			case "UInt8":
			case "unsigned char":
				return AssetValueType.UInt8;
			case "SInt16":
			case "short":
				return AssetValueType.Int16;
			case "UInt16":
			case "unsigned short":
				return AssetValueType.UInt16;
			case "SInt32":
			case "Type*":
			case "int":
				return AssetValueType.Int32;
			case "UInt32":
			case "unsigned int":
				return AssetValueType.UInt32;
			case "SInt64":
			case "long":
				return AssetValueType.Int64;
			case "UInt64":
			case "unsigned long long":
			case "FileSize":
				return AssetValueType.UInt64;
			case "float":
				return AssetValueType.Float;
			case "double":
				return AssetValueType.Double;
			case "bool":
				return AssetValueType.Bool;
			case "Array":
				return AssetValueType.Array;
			case "TypelessData":
				return AssetValueType.ByteArray;
			case "ManagedReferencesRegistry":
				return AssetValueType.ManagedReferencesRegistry;
			default:
				return AssetValueType.None;
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			if (TemplateField.IsArray)
			{
				if (TemplateField.ValueType == AssetValueType.ByteArray)
				{
					byte[] asByteArray = AsByteArray;
					writer.Write(asByteArray.Length);
					writer.Write(asByteArray);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					return;
				}
				int count = Children.Count;
				writer.Write(count);
				for (int i = 0; i < count; i++)
				{
					this[i].Write(writer);
				}
				if (TemplateField.IsAligned)
				{
					writer.Align();
				}
			}
			else if (Children.Count == 0)
			{
				switch (TemplateField.ValueType)
				{
				case AssetValueType.Int8:
					writer.Write(AsSByte);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					break;
				case AssetValueType.UInt8:
					writer.Write(AsByte);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					break;
				case AssetValueType.Bool:
					writer.Write(AsBool);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					break;
				case AssetValueType.Int16:
					writer.Write(AsShort);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					break;
				case AssetValueType.UInt16:
					writer.Write(AsUShort);
					if (TemplateField.IsAligned)
					{
						writer.Align();
					}
					break;
				case AssetValueType.Int32:
					writer.Write(AsInt);
					break;
				case AssetValueType.UInt32:
					writer.Write(AsUInt);
					break;
				case AssetValueType.Int64:
					writer.Write(AsLong);
					break;
				case AssetValueType.UInt64:
					writer.Write(AsULong);
					break;
				case AssetValueType.Float:
					writer.Write(AsFloat);
					break;
				case AssetValueType.Double:
					writer.Write(AsDouble);
					break;
				case AssetValueType.String:
					writer.Write(AsByteArray.Length);
					writer.Write(AsByteArray);
					writer.Align();
					break;
				case AssetValueType.ManagedReferencesRegistry:
				{
					writer.Write(AsManagedReferencesRegistry.version);
					int count2 = AsManagedReferencesRegistry.references.Count;
					for (int j = 0; j < count2; j++)
					{
						AssetTypeReferencedObject assetTypeReferencedObject = AsManagedReferencesRegistry.references[j];
						if (AsManagedReferencesRegistry.version != 1)
						{
							writer.Write(assetTypeReferencedObject.rid);
						}
						assetTypeReferencedObject.type.WriteAsset(writer);
						assetTypeReferencedObject.data.Write(writer);
					}
					if (AsManagedReferencesRegistry.version == 1)
					{
						AssetTypeReference.TERMINUS.WriteAsset(writer);
					}
					break;
				}
				case AssetValueType.Array:
				case AssetValueType.ByteArray:
					break;
				}
			}
			else
			{
				for (int k = 0; k < Children.Count; k++)
				{
					this[k].Write(writer);
				}
				if (TemplateField.IsAligned)
				{
					writer.Align();
				}
			}
		}

		public byte[] WriteToByteArray(bool bigEndian = false)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using AssetsFileWriter assetsFileWriter = new AssetsFileWriter(memoryStream);
			assetsFileWriter.BigEndian = bigEndian;
			Write(assetsFileWriter);
			return memoryStream.ToArray();
		}

		public IEnumerator<AssetTypeValueField> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return Children.GetEnumerator();
		}

		public override string ToString()
		{
			if (TemplateField != null)
			{
				return TemplateField.ToString();
			}
			return null;
		}
	}
	public class DummyFieldAccessException : Exception
	{
		public DummyFieldAccessException(string message)
			: base(message)
		{
		}
	}
	public enum AssetValueType
	{
		None,
		Bool,
		Int8,
		UInt8,
		Int16,
		UInt16,
		Int32,
		UInt32,
		Int64,
		UInt64,
		Float,
		Double,
		String,
		Array,
		ByteArray,
		ManagedReferencesRegistry
	}
	public class ManagedReferencesRegistry
	{
		public int version;

		public List<AssetTypeReferencedObject> references;
	}
	public class RefTypeManager
	{
		private Dictionary<AssetTypeReference, AssetTypeTemplateField> typeTreeLookup;

		private Dictionary<AssetTypeReference, AssetTypeTemplateField> monoTemplateLookup;

		private IMonoBehaviourTemplateGenerator monoTemplateGenerator;

		private UnityVersion unityVersion;

		private bool isSharedMonoLookup;

		public RefTypeManager()
		{
			typeTreeLookup = new Dictionary<AssetTypeReference, AssetTypeTemplateField>();
		}

		public void Clear()
		{
			typeTreeLookup.Clear();
			if (!isSharedMonoLookup)
			{
				monoTemplateLookup.Clear();
			}
		}

		public void FromTypeTree(AssetsFileMetadata metadata)
		{
			if (!metadata.TypeTreeEnabled || metadata.RefTypes == null)
			{
				return;
			}
			foreach (TypeTreeType refType in metadata.RefTypes)
			{
				if (refType.IsRefType)
				{
					AssetTypeTemplateField assetTypeTemplateField = new AssetTypeTemplateField();
					assetTypeTemplateField.FromTypeTree(refType);
					if (assetTypeTemplateField.Children.Count > 0 && assetTypeTemplateField.Children[assetTypeTemplateField.Children.Count - 1].ValueType == AssetValueType.ManagedReferencesRegistry)
					{
						assetTypeTemplateField.Children.RemoveAt(assetTypeTemplateField.Children.Count - 1);
					}
					typeTreeLookup[refType.TypeReference] = assetTypeTemplateField;
				}
			}
		}

		public void WithMonoTemplateGenerator(AssetsFileMetadata metadata, IMonoBehaviourTemplateGenerator monoTemplateGenerator, Dictionary<AssetTypeReference, AssetTypeTemplateField> monoTemplateFieldCache = null)
		{
			this.monoTemplateGenerator = monoTemplateGenerator;
			unityVersion = new UnityVersion(metadata.UnityVersion);
			monoTemplateLookup = monoTemplateFieldCache ?? new Dictionary<AssetTypeReference, AssetTypeTemplateField>();
			isSharedMonoLookup = monoTemplateLookup != null;
		}

		public AssetTypeTemplateField GetTemplateField(AssetTypeReference type)
		{
			if (type == null || (string.IsNullOrEmpty(type.ClassName) && string.IsNullOrEmpty(type.Namespace) && string.IsNullOrEmpty(type.AsmName)) || type.Equals(AssetTypeReference.TERMINUS))
			{
				return null;
			}
			if (typeTreeLookup.TryGetValue(type, out var value))
			{
				return value;
			}
			if (monoTemplateGenerator != null)
			{
				if (monoTemplateLookup.TryGetValue(type, out value))
				{
					return value;
				}
				value = new AssetTypeTemplateField
				{
					Name = "Base",
					Type = type.ClassName,
					ValueType = AssetValueType.None,
					IsArray = false,
					IsAligned = false,
					HasValue = false,
					Children = new List<AssetTypeTemplateField>(0)
				};
				value = monoTemplateGenerator.GetTemplateField(value, type.AsmName, type.Namespace, type.ClassName, unityVersion);
				if (value != null)
				{
					monoTemplateLookup[type] = value;
					return value;
				}
			}
			return null;
		}
	}
	public class ClassDatabaseFile
	{
		public ClassDatabaseFileHeader Header { get; set; }

		public List<ClassDatabaseType> Classes { get; set; }

		public ClassDatabaseStringTable StringTable { get; set; }

		public List<ushort> CommonStringBufferIndices { get; set; }

		public void Read(AssetsFileReader reader)
		{
			if (Header == null)
			{
				ClassDatabaseFileHeader classDatabaseFileHeader2 = (Header = new ClassDatabaseFileHeader());
			}
			Header.Read(reader);
			AssetsFileReader decompressedReader = GetDecompressedReader(reader);
			int num = decompressedReader.ReadInt32();
			Classes = new List<ClassDatabaseType>(num);
			for (int i = 0; i < num; i++)
			{
				ClassDatabaseType classDatabaseType = new ClassDatabaseType();
				classDatabaseType.Read(decompressedReader);
				Classes.Add(classDatabaseType);
			}
			if (StringTable == null)
			{
				ClassDatabaseStringTable classDatabaseStringTable2 = (StringTable = new ClassDatabaseStringTable());
			}
			StringTable.Read(decompressedReader);
			if (CommonStringBufferIndices == null)
			{
				List<ushort> list2 = (CommonStringBufferIndices = new List<ushort>());
			}
			int num2 = decompressedReader.ReadInt32();
			for (int j = 0; j < num2; j++)
			{
				CommonStringBufferIndices.Add(decompressedReader.ReadUInt16());
			}
		}

		public void Write(AssetsFileWriter writer, ClassFileCompressionType compressionType)
		{
			Header.CompressionType = compressionType;
			MemoryStream memoryStream = new MemoryStream();
			AssetsFileWriter assetsFileWriter = new AssetsFileWriter(memoryStream);
			assetsFileWriter.Write(Classes.Count);
			for (int i = 0; i < Classes.Count; i++)
			{
				Classes[i].Write(assetsFileWriter);
			}
			StringTable.Write(assetsFileWriter);
			assetsFileWriter.Write(CommonStringBufferIndices.Count);
			for (int j = 0; j < CommonStringBufferIndices.Count; j++)
			{
				assetsFileWriter.Write(CommonStringBufferIndices[j]);
			}
			using MemoryStream memoryStream2 = GetCompressedStream(memoryStream);
			Header.CompressedSize = (int)memoryStream2.Length;
			Header.DecompressedSize = (int)memoryStream.Length;
			Header.Write(writer);
			memoryStream2.CopyToCompat(writer.BaseStream, -1L);
		}

		private AssetsFileReader GetDecompressedReader(AssetsFileReader reader)
		{
			AssetsFileReader result = reader;
			if (Header.CompressionType != 0)
			{
				MemoryStream stream;
				if (Header.CompressionType == ClassFileCompressionType.Lz4)
				{
					byte[] buffer = new byte[Header.DecompressedSize];
					using (MemoryStream input = new MemoryStream(reader.ReadBytes(Header.CompressedSize)))
					{
						Lz4DecoderStream lz4DecoderStream = new Lz4DecoderStream(input);
						lz4DecoderStream.Read(buffer, 0, Header.DecompressedSize);
						lz4DecoderStream.Dispose();
					}
					stream = new MemoryStream(buffer);
				}
				else
				{
					if (Header.CompressionType != ClassFileCompressionType.Lzma)
					{
						throw new Exception($"Class database is using invalid compression type {Header.CompressionType}!");
					}
					using MemoryStream newInStream = new MemoryStream(reader.ReadBytes(Header.CompressedSize));
					stream = SevenZipHelper.StreamDecompress(newInStream);
				}
				result = new AssetsFileReader(stream);
			}
			return result;
		}

		private MemoryStream GetCompressedStream(MemoryStream inStream)
		{
			if (Header.CompressionType != 0)
			{
				if (Header.CompressionType == ClassFileCompressionType.Lz4)
				{
					byte[] buffer = LZ4Codec.Encode32HC(inStream.ToArray(), 0, (int)inStream.Length);
					return new MemoryStream(buffer);
				}
				if (Header.CompressionType == ClassFileCompressionType.Lzma)
				{
					MemoryStream memoryStream = new MemoryStream();
					SevenZipHelper.Compress(inStream, memoryStream);
					memoryStream.Position = 0L;
					return memoryStream;
				}
				throw new Exception($"Class database is using invalid compression type {Header.CompressionType}!");
			}
			inStream.Position = 0L;
			return inStream;
		}

		public ClassDatabaseType FindAssetClassByID(int id)
		{
			if (id < 0)
			{
				id = 114;
			}
			foreach (ClassDatabaseType @class in Classes)
			{
				if (@class.ClassId == id)
				{
					return @class;
				}
			}
			return null;
		}

		public ClassDatabaseType FindAssetClassByName(string name)
		{
			foreach (ClassDatabaseType @class in Classes)
			{
				if (GetString(@class.Name) == name)
				{
					return @class;
				}
			}
			return null;
		}

		public string GetString(ushort index)
		{
			return StringTable.GetString(index);
		}
	}
	public class ClassDatabaseFileHeader
	{
		public string Magic { get; set; }

		public byte FileVersion { get; set; }

		public UnityVersion Version { get; set; }

		public ClassFileCompressionType CompressionType { get; set; }

		public int CompressedSize { get; set; }

		public int DecompressedSize { get; set; }

		public void Read(AssetsFileReader reader)
		{
			Magic = reader.ReadStringLength(4);
			if (Magic != "CLDB")
			{
				if (Magic == "cldb")
				{
					throw new NotSupportedException("Old cldb style class databases are no longer supported.");
				}
				throw new NotSupportedException("CLDB magic not found. Is this really a class database file?");
			}
			FileVersion = reader.ReadByte();
			if (FileVersion > 1)
			{
				throw new Exception($"Unsupported or invalid file version {FileVersion}.");
			}
			Version = UnityVersion.FromUInt64(reader.ReadUInt64());
			CompressionType = (ClassFileCompressionType)reader.ReadByte();
			CompressedSize = reader.ReadInt32();
			DecompressedSize = reader.ReadInt32();
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(Encoding.ASCII.GetBytes(Magic));
			writer.Write(FileVersion);
			writer.Write(Version.ToUInt64());
			writer.Write((byte)CompressionType);
			writer.Write(CompressedSize);
			writer.Write(DecompressedSize);
		}
	}
	public class ClassDatabaseStringTable
	{
		public List<string> Strings { get; set; }

		public void Read(AssetsFileReader reader)
		{
			int num = reader.ReadInt32();
			Strings = new List<string>(num);
			for (int i = 0; i < num; i++)
			{
				Strings.Add(reader.ReadString());
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(Strings.Count);
			for (int i = 0; i < Strings.Count; i++)
			{
				writer.Write(Strings[i]);
			}
		}

		public ushort AddString(string str)
		{
			int num = Strings.IndexOf(str);
			if (num == -1)
			{
				num = Strings.Count;
				Strings.Add(str);
			}
			return (ushort)num;
		}

		public string GetString(ushort index)
		{
			return Strings[index];
		}
	}
	public class ClassDatabaseType
	{
		public int ClassId { get; set; }

		public ushort Name { get; set; }

		public ushort BaseName { get; set; }

		public ClassFileTypeFlags Flags { get; set; }

		public ClassDatabaseTypeNode EditorRootNode { get; set; }

		public ClassDatabaseTypeNode ReleaseRootNode { get; set; }

		public void Read(AssetsFileReader reader)
		{
			ClassId = reader.ReadInt32();
			Name = reader.ReadUInt16();
			BaseName = reader.ReadUInt16();
			Flags = (ClassFileTypeFlags)reader.ReadByte();
			EditorRootNode = null;
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasEditorRootNode))
			{
				EditorRootNode = new ClassDatabaseTypeNode();
				EditorRootNode.Read(reader);
			}
			ReleaseRootNode = null;
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasReleaseRootNode))
			{
				ReleaseRootNode = new ClassDatabaseTypeNode();
				ReleaseRootNode.Read(reader);
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(ClassId);
			writer.Write(Name);
			writer.Write(BaseName);
			writer.Write((byte)Flags);
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasEditorRootNode) && EditorRootNode != null)
			{
				EditorRootNode.Write(writer);
			}
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasReleaseRootNode) && ReleaseRootNode != null)
			{
				ReleaseRootNode.Write(writer);
			}
		}

		public ClassDatabaseTypeNode GetPreferredNode(bool preferEditor = false)
		{
			if (EditorRootNode != null && ReleaseRootNode != null)
			{
				return preferEditor ? EditorRootNode : ReleaseRootNode;
			}
			if (EditorRootNode != null)
			{
				return EditorRootNode;
			}
			if (ReleaseRootNode != null)
			{
				return ReleaseRootNode;
			}
			return null;
		}
	}
	public class ClassDatabaseTypeNode
	{
		public ushort TypeName { get; set; }

		public ushort FieldName { get; set; }

		public int ByteSize { get; set; }

		public ushort Version { get; set; }

		public byte TypeFlags { get; set; }

		public uint MetaFlag { get; set; }

		public List<ClassDatabaseTypeNode> Children { get; set; }

		public void Read(AssetsFileReader reader)
		{
			TypeName = reader.ReadUInt16();
			FieldName = reader.ReadUInt16();
			ByteSize = reader.ReadInt32();
			Version = reader.ReadUInt16();
			TypeFlags = reader.ReadByte();
			MetaFlag = reader.ReadUInt32();
			int num = reader.ReadUInt16();
			Children = new List<ClassDatabaseTypeNode>(num);
			for (int i = 0; i < num; i++)
			{
				ClassDatabaseTypeNode classDatabaseTypeNode = new ClassDatabaseTypeNode();
				classDatabaseTypeNode.Read(reader);
				Children.Add(classDatabaseTypeNode);
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(TypeName);
			writer.Write(FieldName);
			writer.Write(ByteSize);
			writer.Write(TypeFlags);
			writer.Write(MetaFlag);
			writer.Write((ushort)Children.Count);
			for (int i = 0; i < Children.Count; i++)
			{
				Children[i].Write(writer);
			}
		}
	}
	public enum ClassFileCompressionType
	{
		Uncompressed,
		Lz4,
		Lzma
	}
	[Flags]
	public enum ClassFileTypeFlags : byte
	{
		None = 0,
		IsAbstract = 1,
		IsSealed = 2,
		IsEditorOnly = 4,
		IsReleaseOnly = 8,
		IsStripped = 0x10,
		Reserved = 0x20,
		HasEditorRootNode = 0x40,
		HasReleaseRootNode = 0x80
	}
	public class ClassPackageFile
	{
		public ClassPackageHeader Header { get; set; }

		public ClassPackageTypeTree TpkTypeTree { get; set; }

		public void Read(AssetsFileReader reader)
		{
			Header = new ClassPackageHeader();
			Header.Read(reader);
			AssetsFileReader assetsFileReader;
			if (Header.CompressionType == ClassFileCompressionType.Lz4)
			{
				byte[] buffer = new byte[Header.DecompressedSize];
				using (MemoryStream input = new MemoryStream(reader.ReadBytes((int)Header.CompressedSize)))
				{
					Lz4DecoderStream lz4DecoderStream = new Lz4DecoderStream(input);
					lz4DecoderStream.Read(buffer, 0, (int)Header.DecompressedSize);
					lz4DecoderStream.Dispose();
				}
				MemoryStream stream = new MemoryStream(buffer);
				assetsFileReader = new AssetsFileReader(stream);
				assetsFileReader.Position = 0L;
			}
			else if (Header.CompressionType == ClassFileCompressionType.Lzma)
			{
				using MemoryStream newInStream = new MemoryStream(reader.ReadBytes((int)Header.CompressedSize));
				MemoryStream stream2 = SevenZipHelper.StreamDecompress(newInStream, (int)Header.DecompressedSize);
				assetsFileReader = new AssetsFileReader(stream2);
				assetsFileReader.Position = 0L;
			}
			else
			{
				assetsFileReader = reader;
			}
			TpkTypeTree = new ClassPackageTypeTree();
			TpkTypeTree.Read(assetsFileReader);
		}

		public void Read(string path)
		{
			Read(new AssetsFileReader(File.OpenRead(path)));
		}

		public void Write(AssetsFileWriter writer, ClassFileCompressionType compressionType)
		{
			Header.CompressionType = compressionType;
			MemoryStream memoryStream = new MemoryStream();
			AssetsFileWriter writer2 = new AssetsFileWriter(memoryStream);
			TpkTypeTree.Write(writer2);
			if (Header.CompressionType == ClassFileCompressionType.Lz4)
			{
				byte[] array = LZ4Codec.Encode32HC(memoryStream.ToArray(), 0, (int)memoryStream.Length);
				Header.CompressedSize = (uint)array.Length;
				Header.DecompressedSize = (uint)memoryStream.Length;
				Header.Write(writer);
				writer.Write(array);
			}
			else if (Header.CompressionType == ClassFileCompressionType.Lzma)
			{
				MemoryStream memoryStream2 = new MemoryStream();
				SevenZipHelper.Compress(memoryStream, memoryStream2);
				Header.CompressedSize = (uint)memoryStream2.Length;
				Header.DecompressedSize = (uint)memoryStream.Length;
				Header.Write(writer);
				memoryStream2.CopyToCompat(writer.BaseStream, -1L);
			}
			else
			{
				Header.CompressedSize = (uint)memoryStream.Length;
				Header.DecompressedSize = (uint)memoryStream.Length;
				Header.Write(writer);
				memoryStream.CopyToCompat(writer.BaseStream, -1L);
			}
		}

		public void Write(string path, ClassFileCompressionType compressionType)
		{
			Write(new AssetsFileWriter(File.OpenWrite(path)), compressionType);
		}

		public ClassDatabaseFile GetClassDatabase(string version)
		{
			return GetClassDatabase(new UnityVersion(version));
		}

		public ClassDatabaseFile GetClassDatabase(UnityVersion version)
		{
			if (Header == null)
			{
				throw new Exception("Header not loaded! (Did you forget to call package.Read?)");
			}
			ClassDatabaseFile classDatabaseFile = new ClassDatabaseFile();
			classDatabaseFile.Header = new ClassDatabaseFileHeader
			{
				Magic = "CLDB",
				FileVersion = 1,
				Version = version,
				CompressionType = ClassFileCompressionType.Uncompressed,
				CompressedSize = 0,
				DecompressedSize = 0
			};
			classDatabaseFile.Classes = new List<ClassDatabaseType>();
			foreach (ClassPackageClassInfo item in TpkTypeTree.ClassInformation)
			{
				ClassPackageType typeForVersion = item.GetTypeForVersion(version);
				if (typeForVersion != null)
				{
					ClassDatabaseType classDatabaseType = new ClassDatabaseType
					{
						ClassId = item.ClassId,
						Name = typeForVersion.Name,
						BaseName = typeForVersion.BaseName,
						Flags = typeForVersion.Flags
					};
					if (typeForVersion.EditorRootNode != ushort.MaxValue)
					{
						classDatabaseType.EditorRootNode = ConvertNodes(typeForVersion.EditorRootNode);
					}
					if (typeForVersion.ReleaseRootNode != ushort.MaxValue)
					{
						classDatabaseType.ReleaseRootNode = ConvertNodes(typeForVersion.ReleaseRootNode);
					}
					classDatabaseFile.Classes.Add(classDatabaseType);
				}
			}
			classDatabaseFile.StringTable = TpkTypeTree.StringTable;
			byte commonStringLengthForVersion = TpkTypeTree.CommonString.GetCommonStringLengthForVersion(version);
			classDatabaseFile.CommonStringBufferIndices = new List<ushort>(commonStringLengthForVersion);
			for (int i = 0; i < commonStringLengthForVersion; i++)
			{
				classDatabaseFile.CommonStringBufferIndices.Add(TpkTypeTree.CommonString.StringBufferIndices[i]);
			}
			return classDatabaseFile;
		}

		private ClassDatabaseTypeNode ConvertNodes(ushort tpkNodeIdx)
		{
			ClassPackageTypeNode classPackageTypeNode = TpkTypeTree.Nodes[tpkNodeIdx];
			ClassDatabaseTypeNode classDatabaseTypeNode = new ClassDatabaseTypeNode
			{
				TypeName = classPackageTypeNode.TypeName,
				FieldName = classPackageTypeNode.FieldName,
				ByteSize = classPackageTypeNode.ByteSize,
				Version = classPackageTypeNode.Version,
				TypeFlags = classPackageTypeNode.TypeFlags,
				MetaFlag = classPackageTypeNode.MetaFlag
			};
			int num = classPackageTypeNode.SubNodes.Length;
			classDatabaseTypeNode.Children = new List<ClassDatabaseTypeNode>(num);
			for (int i = 0; i < num; i++)
			{
				classDatabaseTypeNode.Children.Add(ConvertNodes(classPackageTypeNode.SubNodes[i]));
			}
			return classDatabaseTypeNode;
		}
	}
	public class ClassPackageClassInfo
	{
		public int ClassId { get; set; }

		public List<KeyValuePair<UnityVersion, ClassPackageType>> Classes { get; set; }

		public void Read(AssetsFileReader reader)
		{
			ClassId = reader.ReadInt32();
			int num = reader.ReadInt32();
			Classes = new List<KeyValuePair<UnityVersion, ClassPackageType>>(num);
			for (int i = 0; i < num; i++)
			{
				UnityVersion key = UnityVersion.FromUInt64(reader.ReadUInt64());
				bool flag = reader.ReadBoolean();
				ClassPackageType classPackageType = null;
				if (flag)
				{
					classPackageType = new ClassPackageType();
					classPackageType.Read(reader, ClassId);
				}
				Classes.Add(new KeyValuePair<UnityVersion, ClassPackageType>(key, classPackageType));
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(ClassId);
			writer.Write(Classes.Count);
			for (int i = 0; i < Classes.Count; i++)
			{
				writer.Write(Classes[i].Key.ToUInt64());
				if (Classes[i].Value != null)
				{
					writer.Write((byte)1);
					Classes[i].Value.Write(writer);
				}
				else
				{
					writer.Write((byte)0);
				}
			}
		}

		public ClassPackageType GetTypeForVersion(UnityVersion version)
		{
			if (Classes.Count == 0)
			{
				return null;
			}
			if (Classes[0].Key.ToUInt64() > version.ToUInt64())
			{
				return null;
			}
			ClassPackageType value = Classes[0].Value;
			for (int i = 0; i < Classes.Count; i++)
			{
				if (Classes[i].Key.ToUInt64() == version.ToUInt64())
				{
					return Classes[i].Value;
				}
				if (Classes[i].Key.ToUInt64() > version.ToUInt64())
				{
					return value;
				}
				value = Classes[i].Value;
			}
			return value;
		}
	}
	public class ClassPackageCommonString
	{
		public List<KeyValuePair<UnityVersion, byte>> VersionInformation { get; set; }

		public List<ushort> StringBufferIndices { get; set; }

		public void Read(AssetsFileReader reader)
		{
			int num = reader.ReadInt32();
			VersionInformation = new List<KeyValuePair<UnityVersion, byte>>(num);
			for (int i = 0; i < num; i++)
			{
				UnityVersion key = UnityVersion.FromUInt64(reader.ReadUInt64());
				byte value = reader.ReadByte();
				VersionInformation.Add(new KeyValuePair<UnityVersion, byte>(key, value));
			}
			int num2 = reader.ReadInt32();
			StringBufferIndices = new List<ushort>(num2);
			for (int j = 0; j < num2; j++)
			{
				StringBufferIndices.Add(reader.ReadUInt16());
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(VersionInformation.Count);
			foreach (KeyValuePair<UnityVersion, byte> item in VersionInformation)
			{
				writer.Write(item.Key.ToUInt64());
				writer.Write(item.Value);
			}
			writer.Write(StringBufferIndices.Count);
			for (int i = 0; i < StringBufferIndices.Count; i++)
			{
				writer.Write(StringBufferIndices[i]);
			}
		}

		public byte GetCommonStringLengthForVersion(UnityVersion version)
		{
			if (VersionInformation.Count == 0)
			{
				return 0;
			}
			byte value = VersionInformation[0].Value;
			for (int i = 0; i < VersionInformation.Count; i++)
			{
				if (VersionInformation[i].Key.ToUInt64() >= version.ToUInt64())
				{
					return value;
				}
				value = VersionInformation[i].Value;
			}
			return value;
		}
	}
	public class ClassPackageHeader
	{
		public string Magic { get; set; }

		public byte FileVersion { get; set; }

		public ClassFileCompressionType CompressionType { get; set; }

		public byte DataType { get; set; }

		public uint CompressedSize { get; set; }

		public uint DecompressedSize { get; set; }

		public void Read(AssetsFileReader reader)
		{
			reader.BigEndian = false;
			Magic = reader.ReadStringLength(4);
			if (Magic != "TPK*")
			{
				if (Magic == "CLPK")
				{
					throw new NotSupportedException("Old CLPK style class packages are no longer supported.");
				}
				throw new NotSupportedException("TPK* magic not found. Is this really a tpk file?");
			}
			FileVersion = reader.ReadByte();
			if (FileVersion > 1)
			{
				throw new Exception($"Unsupported or invalid file version {FileVersion}.");
			}
			CompressionType = (ClassFileCompressionType)reader.ReadByte();
			DataType = reader.ReadByte();
			reader.ReadByte();
			reader.ReadUInt32();
			CompressedSize = reader.ReadUInt32();
			DecompressedSize = reader.ReadUInt32();
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.BigEndian = false;
			writer.Write(Encoding.ASCII.GetBytes(Magic));
			writer.Write(FileVersion);
			writer.Write((byte)CompressionType);
			writer.Write(DataType);
			writer.Write((byte)0);
			writer.Write(0);
			writer.Write(CompressedSize);
			writer.Write(DecompressedSize);
		}
	}
	public class ClassPackageType
	{
		public int ClassId { get; set; }

		public ushort Name { get; set; }

		public ushort BaseName { get; set; }

		public ClassFileTypeFlags Flags { get; set; }

		public ushort EditorRootNode { get; set; }

		public ushort ReleaseRootNode { get; set; }

		public void Read(AssetsFileReader reader, int classId)
		{
			ClassId = classId;
			Name = reader.ReadUInt16();
			BaseName = reader.ReadUInt16();
			Flags = (ClassFileTypeFlags)reader.ReadByte();
			EditorRootNode = ushort.MaxValue;
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasEditorRootNode))
			{
				EditorRootNode = reader.ReadUInt16();
			}
			ReleaseRootNode = ushort.MaxValue;
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasReleaseRootNode))
			{
				ReleaseRootNode = reader.ReadUInt16();
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(Name);
			writer.Write(BaseName);
			writer.Write((byte)Flags);
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasEditorRootNode))
			{
				writer.Write(EditorRootNode);
			}
			if (Net35Polyfill.HasFlag(Flags, ClassFileTypeFlags.HasReleaseRootNode))
			{
				writer.Write(ReleaseRootNode);
			}
		}
	}
	public class ClassPackageTypeNode
	{
		public ushort TypeName { get; set; }

		public ushort FieldName { get; set; }

		public int ByteSize { get; set; }

		public ushort Version { get; set; }

		public byte TypeFlags { get; set; }

		public uint MetaFlag { get; set; }

		public ushort[] SubNodes { get; set; }

		public void Read(AssetsFileReader reader)
		{
			TypeName = reader.ReadUInt16();
			FieldName = reader.ReadUInt16();
			ByteSize = reader.ReadInt32();
			Version = reader.ReadUInt16();
			TypeFlags = reader.ReadByte();
			MetaFlag = reader.ReadUInt32();
			ushort num = reader.ReadUInt16();
			SubNodes = new ushort[num];
			for (int i = 0; i < num; i++)
			{
				SubNodes[i] = reader.ReadUInt16();
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(TypeName);
			writer.Write(FieldName);
			writer.Write(ByteSize);
			writer.Write(Version);
			writer.Write(TypeFlags);
			writer.Write(MetaFlag);
			writer.Write(SubNodes.Length);
			for (int i = 0; i < SubNodes.Length; i++)
			{
				writer.Write(SubNodes[i]);
			}
		}
	}
	public class ClassPackageTypeTree
	{
		public DateTime CreationTime { get; set; }

		public List<UnityVersion> Versions { get; set; }

		public List<ClassPackageClassInfo> ClassInformation { get; set; }

		public ClassPackageCommonString CommonString { get; set; }

		public List<ClassPackageTypeNode> Nodes { get; set; }

		public ClassDatabaseStringTable StringTable { get; set; }

		public void Read(AssetsFileReader reader)
		{
			CreationTime = DateTime.FromBinary(reader.ReadInt64());
			int num = reader.ReadInt32();
			Versions = new List<UnityVersion>(num);
			for (int i = 0; i < num; i++)
			{
				Versions.Add(UnityVersion.FromUInt64(reader.ReadUInt64()));
			}
			int num2 = reader.ReadInt32();
			ClassInformation = new List<ClassPackageClassInfo>();
			for (int j = 0; j < num2; j++)
			{
				ClassPackageClassInfo classPackageClassInfo = new ClassPackageClassInfo();
				classPackageClassInfo.Read(reader);
				ClassInformation.Add(classPackageClassInfo);
			}
			CommonString = new ClassPackageCommonString();
			CommonString.Read(reader);
			int num3 = reader.ReadInt32();
			Nodes = new List<ClassPackageTypeNode>(num3);
			for (int k = 0; k < num3; k++)
			{
				ClassPackageTypeNode classPackageTypeNode = new ClassPackageTypeNode();
				classPackageTypeNode.Read(reader);
				Nodes.Add(classPackageTypeNode);
			}
			StringTable = new ClassDatabaseStringTable();
			StringTable.Read(reader);
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(CreationTime.ToBinary());
			writer.Write(Versions.Count);
			for (int i = 0; i < Versions.Count; i++)
			{
				writer.Write(Versions[i].ToUInt64());
			}
			writer.Write(ClassInformation.Count);
			for (int j = 0; j < ClassInformation.Count; j++)
			{
				ClassInformation[j].Write(writer);
			}
			CommonString.Write(writer);
			writer.Write(Nodes.Count);
			for (int k = 0; k < Nodes.Count; k++)
			{
				Nodes[k].Write(writer);
			}
			StringTable.Write(writer);
		}
	}
	public class AssetsFileReader : BinaryReader
	{
		public bool BigEndian { get; set; } = false;


		public long Position
		{
			get
			{
				return BaseStream.Position;
			}
			set
			{
				BaseStream.Position = value;
			}
		}

		public AssetsFileReader(string filePath)
			: base(File.OpenRead(filePath))
		{
		}

		public AssetsFileReader(Stream stream)
			: base(stream)
		{
		}

		public override short ReadInt16()
		{
			return BigEndian ? ((short)ReverseShort((ushort)base.ReadInt16())) : base.ReadInt16();
		}

		public override ushort ReadUInt16()
		{
			return BigEndian ? ReverseShort(base.ReadUInt16()) : base.ReadUInt16();
		}

		public int ReadInt24()
		{
			return BigEndian ? ((int)ReverseInt((uint)BitConverter.ToInt32(ReadBytes(3).Concat(new byte[1]).ToArray(), 0))) : BitConverter.ToInt32(ReadBytes(3).Concat(new byte[1]).ToArray(), 0);
		}

		public uint ReadUInt24()
		{
			return BigEndian ? ReverseInt(BitConverter.ToUInt32(ReadBytes(3).Concat(new byte[1]).ToArray(), 0)) : BitConverter.ToUInt32(ReadBytes(3).Concat(new byte[1]).ToArray(), 0);
		}

		public override int ReadInt32()
		{
			return BigEndian ? ((int)ReverseInt((uint)base.ReadInt32())) : base.ReadInt32();
		}

		public override uint ReadUInt32()
		{
			return BigEndian ? ReverseInt(base.ReadUInt32()) : base.ReadUInt32();
		}

		public override long ReadInt64()
		{
			return BigEndian ? ((long)ReverseLong((ulong)base.ReadInt64())) : base.ReadInt64();
		}

		public override ulong ReadUInt64()
		{
			return BigEndian ? ReverseLong(base.ReadUInt64()) : base.ReadUInt64();
		}

		public ushort ReverseShort(ushort value)
		{
			return (ushort)(((value & 0xFF00) >> 8) | ((value & 0xFF) << 8));
		}

		public uint ReverseInt(uint value)
		{
			value = (value >> 16) | (value << 16);
			return ((value & 0xFF00FF00u) >> 8) | ((value & 0xFF00FF) << 8);
		}

		public ulong ReverseLong(ulong value)
		{
			value = (value >> 32) | (value << 32);
			value = ((value & 0xFFFF0000FFFF0000uL) >> 16) | ((value & 0xFFFF0000FFFFL) << 16);
			return ((value & 0xFF00FF00FF00FF00uL) >> 8) | ((value & 0xFF00FF00FF00FFL) << 8);
		}

		public void Align()
		{
			long num = 4 - BaseStream.Position % 4;
			if (num != 4)
			{
				BaseStream.Position += num;
			}
		}

		public void Align8()
		{
			long num = 8 - BaseStream.Position % 8;
			if (num != 8)
			{
				BaseStream.Position += num;
			}
		}

		public void Align16()
		{
			long num = 16 - BaseStream.Position % 16;
			if (num != 16)
			{
				BaseStream.Position += num;
			}
		}

		public string ReadStringLength(int len)
		{
			return Encoding.UTF8.GetString(ReadBytes(len));
		}

		public string ReadNullTerminated()
		{
			string text = "";
			char c;
			while ((c = ReadChar()) != 0)
			{
				text += c;
			}
			return text;
		}

		public static string ReadNullTerminatedArray(byte[] bytes, uint pos)
		{
			StringBuilder stringBuilder = new StringBuilder();
			char value;
			while ((value = (char)bytes[pos]) != 0)
			{
				stringBuilder.Append(value);
				pos++;
			}
			return stringBuilder.ToString();
		}

		public string ReadCountString()
		{
			byte len = ReadByte();
			return ReadStringLength(len);
		}

		public string ReadCountStringInt16()
		{
			ushort len = ReadUInt16();
			return ReadStringLength(len);
		}

		public string ReadCountStringInt32()
		{
			int len = ReadInt32();
			return ReadStringLength(len);
		}
	}
	public class AssetsFileWriter : BinaryWriter
	{
		public bool BigEndian { get; set; } = false;


		public long Position
		{
			get
			{
				return BaseStream.Position;
			}
			set
			{
				BaseStream.Position = value;
			}
		}

		public AssetsFileWriter(string filePath)
			: base(File.Open(filePath, FileMode.Create, FileAccess.Write))
		{
		}

		public AssetsFileWriter(FileStream fileStream)
			: base(fileStream)
		{
		}

		public AssetsFileWriter(MemoryStream memoryStream)
			: base(memoryStream)
		{
		}

		public AssetsFileWriter(Stream stream)
			: base(stream)
		{
		}

		public override void Write(short val)
		{
			if (BigEndian)
			{
				base.Write((short)ReverseShort((ushort)val));
			}
			else
			{
				base.Write(val);
			}
		}

		public override void Write(ushort val)
		{
			if (BigEndian)
			{
				base.Write(ReverseShort(val));
			}
			else
			{
				base.Write(val);
			}
		}

		public override void Write(int val)
		{
			if (BigEndian)
			{
				base.Write((int)ReverseInt((uint)val));
			}
			else
			{
				base.Write(val);
			}
		}

		public override void Write(uint val)
		{
			if (BigEndian)
			{
				base.Write(ReverseInt(val));
			}
			else
			{
				base.Write(val);
			}
		}

		public override void Write(long val)
		{
			if (BigEndian)
			{
				base.Write((long)ReverseLong((ulong)val));
			}
			else
			{
				base.Write(val);
			}
		}

		public override void Write(ulong val)
		{
			if (BigEndian)
			{
				base.Write(ReverseLong(val));
			}
			else
			{
				base.Write(val);
			}
		}

		public void WriteRawString(string val)
		{
			base.Write(Encoding.UTF8.GetBytes(val));
		}

		public void WriteUInt24(uint val)
		{
			if (BigEndian)
			{
				base.Write(BitConverter.GetBytes(ReverseInt(val)), 1, 3);
			}
			else
			{
				base.Write(BitConverter.GetBytes(val), 0, 3);
			}
		}

		public void WriteInt24(int val)
		{
			if (BigEndian)
			{
				base.Write(BitConverter.GetBytes((int)ReverseInt((uint)val)), 1, 3);
			}
			else
			{
				base.Write(BitConverter.GetBytes(val), 0, 3);
			}
		}

		public ushort ReverseShort(ushort value)
		{
			return (ushort)(((value & 0xFF00) >> 8) | ((value & 0xFF) << 8));
		}

		public uint ReverseInt(uint value)
		{
			value = (value >> 16) | (value << 16);
			return ((value & 0xFF00FF00u) >> 8) | ((value & 0xFF00FF) << 8);
		}

		public ulong ReverseLong(ulong value)
		{
			value = (value >> 32) | (value << 32);
			value = ((value & 0xFFFF0000FFFF0000uL) >> 16) | ((value & 0xFFFF0000FFFFL) << 16);
			return ((value & 0xFF00FF00FF00FF00uL) >> 8) | ((value & 0xFF00FF00FF00FFL) << 8);
		}

		public void Align()
		{
			while (BaseStream.Position % 4 != 0)
			{
				Write((byte)0);
			}
		}

		public void Align8()
		{
			while (BaseStream.Position % 8 != 0)
			{
				Write((byte)0);
			}
		}

		public void Align16()
		{
			while (BaseStream.Position % 16 != 0)
			{
				Write((byte)0);
			}
		}

		public void WriteNullTerminated(string text)
		{
			WriteRawString(text);
			Write((byte)0);
		}

		public void WriteCountString(string text)
		{
			if (Encoding.UTF8.GetByteCount(text) > 255)
			{
				new Exception("String is longer than 255! Use the Int32 variant instead!");
			}
			Write((byte)Encoding.UTF8.GetByteCount(text));
			WriteRawString(text);
		}

		public void WriteCountStringInt16(string text)
		{
			if (Encoding.UTF8.GetByteCount(text) > 65535)
			{
				new Exception("String is longer than 65535! Use the Int32 variant instead!");
			}
			Write((ushort)Encoding.UTF8.GetByteCount(text));
			WriteRawString(text);
		}

		public void WriteCountStringInt32(string text)
		{
			Write(Encoding.UTF8.GetByteCount(text));
			WriteRawString(text);
		}
	}
	public class LZ4BlockStream : Stream
	{
		private readonly long length;

		private readonly long blockSize;

		private readonly AssetBundleBlockInfo[] blockInfos;

		private readonly long[] blockPoses;

		private readonly Dictionary<int, MemoryStream> decompressedBlockMap;

		private readonly Queue<int> decompressedBlockQueue;

		public int maxBlockMapSize;

		public const int DEFAULT_MAX_BLOCK_MAP_SIZE = 382;

		public Stream BaseStream { get; }

		public long BaseOffset { get; }

		public override long Position { get; set; }

		public override long Length => length;

		public override bool CanRead => BaseStream.CanRead;

		public override bool CanSeek => BaseStream.CanSeek;

		public override bool CanWrite => BaseStream.CanWrite;

		public LZ4BlockStream(Stream baseStream, long baseOffset, AssetBundleBlockInfo[] blockInfos, int maxBlockMapSize = 382)
		{
			if (baseOffset < 0 || baseOffset > baseStream.Length)
			{
				throw new ArgumentOutOfRangeException("baseOffset");
			}
			if (length >= 0 && baseOffset + length > baseStream.Length)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			decompressedBlockMap = new Dictionary<int, MemoryStream>();
			decompressedBlockQueue = new Queue<int>();
			if (blockInfos.Length == 0)
			{
				length = 0L;
				blockSize = 131072L;
				BaseStream = new MemoryStream();
				BaseOffset = baseOffset;
				this.blockInfos = new AssetBundleBlockInfo[0];
				blockPoses = new long[0];
				return;
			}
			long num = blockInfos[0].CompressedSize;
			blockPoses = new long[blockInfos.Length];
			blockPoses[0] = 0L;
			blockSize = GetLz4BlockSize(blockInfos);
			length = blockInfos[0].DecompressedSize;
			for (int i = 1; i < blockInfos.Length; i++)
			{
				if (blockInfos[i].DecompressedSize != blockSize && i != blockInfos.Length - 1)
				{
					throw new NotImplementedException("Cannot handle bundles with multiple block sizes yet.");
				}
				length += blockInfos[i].DecompressedSize;
				blockPoses[i] = num;
				num += blockInfos[i].CompressedSize;
			}
			if (blockSize > int.MaxValue)
			{
				throw new NotImplementedException("Block size too large!");
			}
			this.blockInfos = blockInfos;
			this.maxBlockMapSize = maxBlockMapSize;
			BaseStream = baseStream;
			BaseOffset = baseOffset;
		}

		public override void Flush()
		{
			BaseStream.Flush();
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			int num = 0;
			while (num < count)
			{
				int num2 = (int)(Position / blockSize);
				MemoryStream memoryStream2;
				if (!decompressedBlockMap.ContainsKey(num2))
				{
					if (decompressedBlockMap.Count >= maxBlockMapSize)
					{
						int key = decompressedBlockQueue.Dequeue();
						decompressedBlockMap[key].Close();
						decompressedBlockMap.Remove(key);
					}
					BaseStream.Position = BaseOffset + blockPoses[num2];
					MemoryStream memoryStream = new MemoryStream();
					BaseStream.CopyToCompat(memoryStream, blockInfos[num2].CompressedSize);
					memoryStream.Position = 0L;
					byte compressionType = blockInfos[num2].GetCompressionType();
					if (compressionType == 0)
					{
						memoryStream2 = memoryStream;
					}
					else
					{
						if (compressionType != 2 && compressionType != 3)
						{
							throw new Exception("Invalid block compression type in supposed LZ4 only stream!");
						}
						byte[] array = new byte[blockInfos[num2].DecompressedSize];
						using (Lz4DecoderStream lz4DecoderStream = new Lz4DecoderStream(memoryStream))
						{
							lz4DecoderStream.Read(array, 0, array.Length);
						}
						memoryStream2 = new MemoryStream(array);
					}
					decompressedBlockMap[num2] = memoryStream2;
					decompressedBlockQueue.Enqueue(num2);
				}
				else
				{
					memoryStream2 = decompressedBlockMap[num2];
				}
				memoryStream2.Position = Position % blockSize;
				int num3 = memoryStream2.Read(buffer, offset + num, (int)Math.Min(memoryStream2.Length, count - num));
				if (num3 == 0)
				{
					break;
				}
				num += num3;
				Position += num3;
			}
			return num;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			long num = origin switch
			{
				SeekOrigin.Begin => offset, 
				SeekOrigin.Current => Position + offset, 
				SeekOrigin.End => Position + Length + offset, 
				_ => throw new ArgumentException(), 
			};
			if (num < 0 || num > Length)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			Position = num;
			return Position;
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException("LZ4BlockStream cannot be written to, only read from.");
		}

		private long GetLz4BlockSize(AssetBundleBlockInfo[] blockInfos)
		{
			for (int i = 0; i < blockInfos.Length; i++)
			{
				if (blockInfos[i].GetCompressionType() == 2 || blockInfos[i].GetCompressionType() == 3)
				{
					return blockInfos[i].DecompressedSize;
				}
			}
			if (blockInfos[0].GetCompressionType() == 0)
			{
				return blockInfos[0].DecompressedSize;
			}
			throw new Exception("No LZ4 blocks were found in block infos. Can't find block size.");
		}
	}
	public class SegmentStream : Stream
	{
		private readonly long length;

		public Stream BaseStream { get; }

		public long BaseOffset { get; }

		public override long Position { get; set; }

		public override long Length => (length >= 0) ? length : (BaseStream.Length - BaseOffset);

		public override bool CanRead => BaseStream.CanRead;

		public override bool CanSeek => BaseStream.CanSeek;

		public override bool CanWrite => BaseStream.CanWrite;

		public SegmentStream(Stream baseStream, long baseOffset)
			: this(baseStream, baseOffset, -1L)
		{
		}

		public SegmentStream(Stream baseStream, long baseOffset, long length)
		{
			if (baseOffset < 0 || baseOffset > baseStream.Length)
			{
				throw new ArgumentOutOfRangeException("baseOffset");
			}
			if (length >= 0 && baseOffset + length > baseStream.Length)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			BaseStream = baseStream;
			BaseOffset = baseOffset;
			this.length = length;
		}

		public override void Flush()
		{
			BaseStream.Flush();
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			BaseStream.Position = BaseOffset + Position;
			count = BaseStream.Read(buffer, offset, (int)Math.Min(count, Length - Position));
			Position += count;
			return count;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			long num = origin switch
			{
				SeekOrigin.Begin => offset, 
				SeekOrigin.Current => Position + offset, 
				SeekOrigin.End => Position + Length + offset, 
				_ => throw new ArgumentException(), 
			};
			if (num < 0 || num > Length)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			Position = num;
			return Position;
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			if (length >= 0 && count > Length - Position)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			BaseStream.Position = BaseOffset + Position;
			BaseStream.Write(buffer, offset, count);
			Position += count;
		}
	}
	public class ContentRemover : IContentReplacer
	{
		public void Write(AssetsFileWriter writer)
		{
		}

		public bool HasPreview()
		{
			return false;
		}

		public Stream GetPreviewStream()
		{
			return null;
		}

		public ContentReplacerType GetReplacerType()
		{
			return ContentReplacerType.Remove;
		}
	}
	public class ContentReplacerFromAssets : IContentReplacer
	{
		public AssetsFile file;

		public ContentReplacerFromAssets(AssetsFile file)
		{
			this.file = file;
		}

		public ContentReplacerFromAssets(AssetsFileInstance inst)
		{
			file = inst.file;
		}

		public void Write(AssetsFileWriter writer)
		{
			SegmentStream stream = new SegmentStream(writer.BaseStream, writer.Position);
			AssetsFileWriter writer2 = new AssetsFileWriter(stream);
			file.Write(writer2, -1L);
			writer.Position = writer.BaseStream.Length;
		}

		public bool HasPreview()
		{
			return false;
		}

		public Stream GetPreviewStream()
		{
			return null;
		}

		public ContentReplacerType GetReplacerType()
		{
			return ContentReplacerType.AddOrModify;
		}
	}
	public class ContentReplacerFromBuffer : IContentReplacer
	{
		private readonly byte[] buffer;

		private MemoryStream previewStream;

		public ContentReplacerFromBuffer(byte[] buffer)
		{
			this.buffer = buffer;
		}

		public void Write(AssetsFileWriter writer)
		{
			writer.Write(buffer);
		}

		public bool HasPreview()
		{
			return true;
		}

		public Stream GetPreviewStream()
		{
			if (previewStream == null)
			{
				previewStream = new MemoryStream(buffer);
			}
			previewStream.Position = 0L;
			return previewStream;
		}

		public ContentReplacerType GetReplacerType()
		{
			return ContentReplacerType.AddOrModify;
		}
	}
	public class ContentReplacerFromStream : IContentReplacer
	{
		private readonly Stream stream;

		private readonly long offset;

		private readonly long length;

		private readonly bool closeOnWrite;

		public ContentReplacerFromStream(Stream stream, long offset = 0L, int length = -1, bool closeOnWrite = false)
		{
			this.stream = stream;
			this.offset = offset;
			this.length = length;
			this.closeOnWrite = closeOnWrite;
			if (!stream.CanSeek)
			{
				throw new NotSupportedException("Stream needs to be seekable.");
			}
		}

		public void Write(AssetsFileWriter writer)
		{
			if (offset != -1)
			{
				stream.Position = offset;
			}
			stream.CopyToCompat(writer.BaseStream, length);
			if (closeOnWrite)
			{
				stream.Close();
			}
		}

		public bool HasPreview()
		{
			return true;
		}

		public Stream GetPreviewStream()
		{
			if (offset == 0L && length == -1)
			{
				return stream;
			}
			return new SegmentStream(stream, offset, length);
		}

		public ContentReplacerType GetReplacerType()
		{
			return ContentReplacerType.AddOrModify;
		}
	}
	public enum ContentReplacerType
	{
		None,
		AddOrModify,
		Remove
	}
	public interface IContentReplacer
	{
		void Write(AssetsFileWriter writer);

		bool HasPreview();

		Stream GetPreviewStream();

		ContentReplacerType GetReplacerType();
	}
}
namespace AssetsTools.NET.Extra
{
	public enum AssetClassID
	{
		Object = 0,
		GameObject = 1,
		Component = 2,
		LevelGameManager = 3,
		Transform = 4,
		TimeManager = 5,
		GlobalGameManager = 6,
		Behaviour = 8,
		GameManager = 9,
		AudioManager = 11,
		ParticleAnimator = 12,
		InputManager = 13,
		EllipsoidParticleEmitter = 15,
		Pipeline = 17,
		EditorExtension = 18,
		Physics2DSettings = 19,
		Camera = 20,
		Material = 21,
		MeshRenderer = 23,
		Renderer = 25,
		ParticleRenderer = 26,
		Texture = 27,
		Texture2D = 28,
		OcclusionCullingSettings = 29,
		GraphicsSettings = 30,
		MeshFilter = 33,
		OcclusionPortal = 41,
		Mesh = 43,
		Skybox = 45,
		QualitySettings = 47,
		Shader = 48,
		TextAsset = 49,
		Rigidbody2D = 50,
		Physics2DManager = 51,
		NotificationManager = 52,
		Collider2D = 53,
		Rigidbody = 54,
		PhysicsManager = 55,
		Collider = 56,
		Joint = 57,
		CircleCollider2D = 58,
		HingeJoint = 59,
		PolygonCollider2D = 60,
		BoxCollider2D = 61,
		PhysicsMaterial2D = 62,
		MeshCollider = 64,
		BoxCollider = 65,
		CompositeCollider2D = 66,
		EdgeCollider2D = 68,
		PolygonColliderBase2D = 69,
		CapsuleCollider2D = 70,
		AnimationManager = 71,
		ComputeShader = 72,
		AnimationClip = 74,
		ConstantForce = 75,
		WorldParticleCollider = 76,
		TagManager = 78,
		AudioListener = 81,
		AudioSource = 82,
		AudioClip = 83,
		RenderTexture = 84,
		CustomRenderTexture = 86,
		MeshParticleEmitter = 87,
		ParticleEmitter = 88,
		Cubemap = 89,
		Avatar = 90,
		AnimatorController = 91,
		GUILayer = 92,
		RuntimeAnimatorController = 93,
		ScriptMapper = 94,
		Animator = 95,
		TrailRenderer = 96,
		DelayedCallManager = 98,
		TextMesh = 102,
		RenderSettings = 104,
		Light = 108,
		CGProgram = 109,
		BaseAnimationTrack = 110,
		Animation = 111,
		MonoBehaviour = 114,
		MonoScript = 115,
		MonoManager = 116,
		Texture3D = 117,
		NewAnimationTrack = 118,
		Projector = 119,
		LineRenderer = 120,
		Flare = 121,
		Halo = 122,
		LensFlare = 123,
		FlareLayer = 124,
		HaloLayer = 125,
		NavMeshProjectSettings = 126,
		HaloManager = 127,
		Font = 128,
		PlayerSettings = 129,
		NamedObject = 130,
		GUITexture = 131,
		GUIText = 132,
		GUIElement = 133,
		PhysicMaterial = 134,
		SphereCollider = 135,
		CapsuleCollider = 136,
		SkinnedMeshRenderer = 137,
		FixedJoint = 138,
		RaycastCollider = 140,
		BuildSettings = 141,
		AssetBundle = 142,
		CharacterController = 143,
		CharacterJoint = 144,
		SpringJoint = 145,
		WheelCollider = 146,
		ResourceManager = 147,
		NetworkView = 148,
		NetworkManager = 149,
		PreloadData = 150,
		MovieTexture = 152,
		ConfigurableJoint = 153,
		TerrainCollider = 154,
		MasterServerInterface = 155,
		TerrainData = 156,
		LightmapSettings = 157,
		WebCamTexture = 158,
		EditorSettings = 159,
		InteractiveCloth = 160,
		ClothRenderer = 161,
		EditorUserSettings = 162,
		SkinnedCloth = 163,
		AudioReverbFilter = 164,
		AudioHighPassFilter = 165,
		AudioChorusFilter = 166,
		AudioReverbZone = 167,
		AudioEchoFilter = 168,
		AudioLowPassFilter = 169,
		AudioDistortionFilter = 170,
		SparseTexture = 171,
		AudioBehaviour = 180,
		AudioFilter = 181,
		WindZone = 182,
		Cloth = 183,
		SubstanceArchive = 184,
		ProceduralMaterial = 185,
		ProceduralTexture = 186,
		Texture2DArray = 187,
		CubemapArray = 188,
		OffMeshLink = 191,
		OcclusionArea = 192,
		Tree = 193,
		NavMeshObsolete = 194,
		NavMeshAgent = 195,
		NavMeshSettings = 196,
		LightProbesLegacy = 197,
		ParticleSystem = 198,
		ParticleSystemRenderer = 199,
		ShaderVariantCollection = 200,
		LODGroup = 205,
		BlendTree = 206,
		Motion = 207,
		NavMeshObstacle = 208,
		SortingGroup = 210,
		SpriteRenderer = 212,
		Sprite = 213,
		CachedSpriteAtlas = 214,
		ReflectionProbe = 215,
		ReflectionProbes = 216,
		Terrain = 218,
		LightProbeGroup = 220,
		AnimatorOverrideController = 221,
		CanvasRenderer = 222,
		Canvas = 223,
		RectTransform = 224,
		CanvasGroup = 225,
		BillboardAsset = 226,
		BillboardRenderer = 227,
		SpeedTreeWindAsset = 228,
		AnchoredJoint2D = 229,
		Joint2D = 230,
		SpringJoint2D = 231,
		DistanceJoint2D = 232,
		HingeJoint2D = 233,
		SliderJoint2D = 234,
		WheelJoint2D = 235,
		ClusterInputManager = 236,
		BaseVideoTexture = 237,
		NavMeshData = 238,
		AudioMixer = 240,
		AudioMixerController = 241,
		AudioMixerGroupController = 243,
		AudioMixerEffectController = 244,
		AudioMixerSnapshotController = 245,
		PhysicsUpdateBehaviour2D = 246,
		ConstantForce2D = 247,
		Effector2D = 248,
		AreaEffector2D = 249,
		PointEffector2D = 250,
		PlatformEffector2D = 251,
		SurfaceEffector2D = 252,
		BuoyancyEffector2D = 253,
		RelativeJoint2D = 254,
		FixedJoint2D = 255,
		FrictionJoint2D = 256,
		TargetJoint2D = 257,
		LightProbes = 258,
		LightProbeProxyVolume = 259,
		SampleClip = 271,
		AudioMixerSnapshot = 272,
		AudioMixerGroup = 273,
		NScreenBridge = 280,
		AssetBundleManifest = 290,
		UnityAdsManager = 292,
		RuntimeInitializeOnLoadManager = 300,
		CloudWebServicesManager = 301,
		CloudServiceHandlerBehaviour = 302,
		UnityAnalyticsManager = 303,
		CrashReportManager = 304,
		PerformanceReportingManager = 305,
		UnityConnectSettings = 310,
		AvatarMask = 319,
		PlayableDirector = 320,
		VideoPlayer = 328,
		VideoClip = 329,
		ParticleSystemForceField = 330,
		SpriteMask = 331,
		WorldAnchor = 362,
		OcclusionCullingData = 363,
		SmallestEditorClassID = 1000,
		PrefabInstance = 1001,
		EditorExtensionImpl = 1002,
		AssetImporter = 1003,
		AssetDatabaseV1 = 1004,
		Mesh3DSImporter = 1005,
		TextureImporter = 1006,
		ShaderImporter = 1007,
		ComputeShaderImporter = 1008,
		AudioImporter = 1020,
		HierarchyState = 1026,
		GUIDSerializer = 1027,
		AssetMetaData = 1028,
		DefaultAsset = 1029,
		DefaultImporter = 1030,
		TextScriptImporter = 1031,
		SceneAsset = 1032,
		NativeFormatImporter = 1034,
		MonoImporter = 1035,
		AssetServerCache = 1037,
		LibraryAssetImporter = 1038,
		ModelImporter = 1040,
		FBXImporter = 1041,
		TrueTypeFontImporter = 1042,
		MovieImporter = 1044,
		EditorBuildSettings = 1045,
		DDSImporter = 1046,
		InspectorExpandedState = 1048,
		AnnotationManager = 1049,
		PluginImporter = 1050,
		EditorUserBuildSettings = 1051,
		PVRImporter = 1052,
		ASTCImporter = 1053,
		KTXImporter = 1054,
		IHVImageFormatImporter = 1055,
		AnimatorStateTransition = 1101,
		AnimatorState = 1102,
		HumanTemplate = 1105,
		AnimatorStateMachine = 1107,
		PreviewAnimationClip = 1108,
		AnimatorTransition = 1109,
		SpeedTreeImporter = 1110,
		AnimatorTransitionBase = 1111,
		SubstanceImporter = 1112,
		LightmapParameters = 1113,
		LightingDataAsset = 1120,
		GISRaster = 1121,
		GISRasterImporter = 1122,
		CadImporter = 1123,
		SketchUpImporter = 1124,
		BuildReport = 1125,
		PackedAssets = 1126,
		VideoClipImporter = 1127,
		ActivationLogComponent = 2000,
		@int = 100000,
		@bool = 100001,
		@float = 100002,
		MonoObject = 100003,
		Collision = 100004,
		Vector3f = 100005,
		RootMotionData = 100006,
		Collision2D = 100007,
		AudioMixerLiveUpdateFloat = 100008,
		AudioMixerLiveUpdateBool = 100009,
		Polygon2D = 100010,
		@void = 100011,
		TilemapCollider2D = 19719996,
		AssetImporterLog = 41386430,
		VFXRenderer = 73398921,
		SerializableManagedRefTestClass = 76251197,
		Grid = 156049354,
		ScenesUsingAssets = 156483287,
		ArticulationBody = 171741748,
		Preset = 181963792,
		EmptyObject = 277625683,
		IConstraint = 285090594,
		TestObjectWithSpecialLayoutOne = 293259124,
		AssemblyDefinitionReferenceImporter = 294290339,
		SiblingDerived = 334799969,
		TestObjectWithSerializedMapStringNonAlignedStruct = 342846651,
		SubDerived = 367388927,
		AssetImportInProgressProxy = 369655926,
		PluginBuildInfo = 382020655,
		EditorProjectAccess = 426301858,
		PrefabImporter = 468431735,
		TestObjectWithSerializedArray = 478637458,
		TestObjectWithSerializedAnimationCurve = 478637459,
		TilemapRenderer = 483693784,
		ScriptableCamera = 488575907,
		SpriteAtlasAsset = 612988286,
		SpriteAtlasDatabase = 638013454,
		AudioBuildInfo = 641289076,
		CachedSpriteAtlasRuntimeData = 644342135,
		RendererFake = 646504946,
		AssemblyDefinitionReferenceAsset = 662584278,
		BuiltAssetBundleInfoSet = 668709126,
		SpriteAtlas = 687078895,
		RayTracingShaderImporter = 747330370,
		PreviewImporter = 815301076,
		RayTracingShader = 825902497,
		LightingSettings = 850595691,
		PlatformModuleSetup = 877146078,
		VersionControlSettings = 890905787,
		AimConstraint = 895512359,
		VFXManager = 937362698,
		VisualEffectSubgraph = 994735392,
		RuleSetFileAsset = 954905827,
		VisualEffectSubgraphOperator = 994735403,
		VisualEffectSubgraphBlock = 994735404,
		Prefab = 1001480554,
		LocalizationImporter = 1027052791,
		Derived = 1091556383,
		PropertyModificationsTargetTestObject = 1111377672,
		ReferencesArtifactGenerator = 1114811875,
		AssemblyDefinitionAsset = 1152215463,
		SceneVisibilityState = 1154873562,
		LookAtConstraint = 1183024399,
		SpriteAtlasImporter = 1210832254,
		MultiArtifactTestImporter = 1223240404,
		GameObjectRecorder = 1268269756,
		LightingDataAssetParent = 1325145578,
		PresetManager = 1386491679,
		TestObjectWithSpecialLayoutTwo = 1392443030,
		StreamingManager = 1403656975,
		LowerResBlitTexture = 1480428607,
		StreamingController = 1542919678,
		RenderPassAttachment = 1571458007,
		TestObjectVectorPairStringBool = 1628831178,
		GridLayout = 1742807556,
		AssemblyDefinitionImporter = 1766753193,
		ParentConstraint = 1773428102,
		FakeComponent = 1803986026,
		RuleSetFileImporter = 1777034230,
		PositionConstraint = 1818360608,
		RotationConstraint = 1818360609,
		ScaleConstraint = 1818360610,
		Tilemap = 1839735485,
		PackageManifest = 1896753125,
		PackageManifestImporter = 1896753126,
		TerrainLayer = 1953259897,
		SpriteShapeRenderer = 1971053207,
		NativeObjectType = 1977754360,
		TestObjectWithSerializedMapStringBool = 1981279845,
		SerializableManagedHost = 1995898324,
		VisualEffectAsset = 2058629509,
		VisualEffectImporter = 2058629510,
		VisualEffectResource = 2058629511,
		VisualEffectObject = 2059678085,
		VisualEffect = 2083052967,
		LocalizationAsset = 2083778819,
		ScriptedImporter = 2089858483,
		TilemapEditorUserSettings = 2126867596
	}
	public static class AssetHelper
	{
		public static Dictionary<int, AssetTypeReference> GetAssetsFileScriptInfos(AssetsManager am, AssetsFileInstance inst)
		{
			Dictionary<int, AssetTypeReference> dictionary = new Dictionary<int, AssetTypeReference>();
			List<AssetPPtr> scriptTypes = inst.file.Metadata.ScriptTypes;
			for (int i = 0; i < scriptTypes.Count; i++)
			{
				AssetTypeReference assetsFileScriptInfo = GetAssetsFileScriptInfo(am, inst, i);
				if (assetsFileScriptInfo != null)
				{
					dictionary[i] = assetsFileScriptInfo;
				}
			}
			return dictionary;
		}

		public static AssetTypeReference GetAssetsFileScriptInfo(AssetsManager am, AssetsFileInstance inst, int index)
		{
			List<AssetPPtr> scriptTypes = inst.file.Metadata.ScriptTypes;
			AssetPPtr assetPPtr = scriptTypes[index];
			AssetTypeValueField baseField;
			try
			{
				baseField = am.GetExtAsset(inst, assetPPtr.FileId, assetPPtr.PathId).baseField;
				if (baseField == null)
				{
					return null;
				}
			}
			catch
			{
				return null;
			}
			AssetTypeValueField assetTypeValueField = baseField["m_AssemblyName"];
			AssetTypeValueField assetTypeValueField2 = baseField["m_Namespace"];
			AssetTypeValueField assetTypeValueField3 = baseField["m_ClassName"];
			if (assetTypeValueField.IsDummy || assetTypeValueField2.IsDummy || assetTypeValueField3.IsDummy)
			{
				return null;
			}
			string asString = assetTypeValueField.AsString;
			string asString2 = assetTypeValueField2.AsString;
			string asString3 = assetTypeValueField3.AsString;
			return new AssetTypeReference(asString3, asString2, asString);
		}

		public static string GetAssetNameFast(AssetsFile file, ClassDatabaseFile cldb, AssetFileInfo info)
		{
			ClassDatabaseType classDatabaseType = cldb.FindAssetClassByID(info.TypeId);
			AssetsFileReader reader = file.Reader;
			if (file.Metadata.TypeTreeEnabled)
			{
				ushort scriptIndex = file.GetScriptIndex(info);
				TypeTreeType typeTreeType = file.Metadata.FindTypeTreeTypeByID(info.TypeId, scriptIndex);
				string typeString = typeTreeType.Nodes[0].GetTypeString(typeTreeType.StringBufferBytes);
				if (typeTreeType.Nodes.Count == 0)
				{
					return cldb.GetString(classDatabaseType.Name);
				}
				if (typeTreeType.Nodes.Count > 1 && typeTreeType.Nodes[1].GetNameString(typeTreeType.StringBufferBytes) == "m_Name")
				{
					reader.Position = info.GetAbsoluteByteOffset(file);
					return reader.ReadCountStringInt32();
				}
				if (typeString == "GameObject")
				{
					reader.Position = info.GetAbsoluteByteOffset(file);
					int num = reader.ReadInt32();
					int num2 = ((file.Header.Version > 16) ? 12 : 16);
					reader.Position += num * num2;
					reader.Position += 4L;
					return reader.ReadCountStringInt32();
				}
				if (typeString == "MonoBehaviour")
				{
					reader.Position = info.GetAbsoluteByteOffset(file);
					reader.Position += 28L;
					string text = reader.ReadCountStringInt32();
					if (text != "")
					{
						return text;
					}
				}
				return typeString;
			}
			string @string = cldb.GetString(classDatabaseType.Name);
			if (classDatabaseType.ReleaseRootNode.Children.Count == 0)
			{
				return @string;
			}
			if (classDatabaseType.ReleaseRootNode.Children.Count > 1 && cldb.GetString(classDatabaseType.ReleaseRootNode.Children[0].FieldName) == "m_Name")
			{
				reader.Position = info.GetAbsoluteByteOffset(file);
				return reader.ReadCountStringInt32();
			}
			if (@string == "GameObject")
			{
				reader.Position = info.GetAbsoluteByteOffset(file);
				int num3 = reader.ReadInt32();
				int num4 = ((file.Header.Version > 16) ? 12 : 16);
				reader.Position += num3 * num4;
				reader.Position += 4L;
				return reader.ReadCountStringInt32();
			}
			if (@string == "MonoBehaviour")
			{
				reader.Position = info.GetAbsoluteByteOffset(file);
				reader.Position += 28L;
				string text2 = reader.ReadCountStringInt32();
				if (text2 != "")
				{
					return text2;
				}
			}
			return @string;
		}
	}
	[Obsolete("use AssetPPtr")]
	public class AssetID
	{
		public string fileName;

		public long pathID;

		public AssetID(string fileName, long pathID)
		{
			this.fileName = fileName;
			this.pathID = pathID;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is AssetID))
			{
				return false;
			}
			AssetID assetID = (AssetID)obj;
			return assetID.fileName == fileName && assetID.pathID == pathID;
		}

		public override int GetHashCode()
		{
			int num = 17;
			num = num * 23 + fileName.GetHashCode();
			return num * 23 + pathID.GetHashCode();
		}
	}
	[Flags]
	public enum AssetReadFlags
	{
		None = 0,
		PreferEditor = 1,
		SkipMonoBehaviourFields = 2,
		ForceFromCldb = 4
	}
	public class AssetsFileInstance
	{
		public string path;

		public string name;

		public AssetsFile file;

		public BundleFileInstance parentBundle = null;

		internal Dictionary<int, AssetsFileInstance> dependencyCache;

		public Stream AssetsStream => file.Reader.BaseStream;

		public AssetsFileInstance(Stream stream, string filePath)
		{
			path = Path.GetFullPath(filePath);
			name = Path.GetFileName(path);
			file = new AssetsFile();
			file.Read(new AssetsFileReader(stream));
			dependencyCache = new Dictionary<int, AssetsFileInstance>();
		}

		public AssetsFileInstance(FileStream stream)
		{
			path = stream.Name;
			name = Path.GetFileName(path);
			file = new AssetsFile();
			file.Read(new AssetsFileReader(stream));
			dependencyCache = new Dictionary<int, AssetsFileInstance>();
		}

		public AssetsFileInstance GetDependency(AssetsManager am, int depIdx)
		{
			if (!dependencyCache.ContainsKey(depIdx) || dependencyCache[depIdx] == null)
			{
				string depPath = file.Metadata.Externals[depIdx].PathName;
				if (depPath == string.Empty)
				{
					return null;
				}
				if (depPath.StartsWith("archive:/"))
				{
					depPath = depPath.Substring(depPath.IndexOf('/', "archive:/".Length) + 1);
				}
				if (!am.FileLookup.TryGetValue(am.GetFileLookupKey(depPath), out var value))
				{
					string directoryName = Path.GetDirectoryName(path);
					string text = Path.Combine(directoryName, depPath);
					string text2 = Path.Combine(directoryName, Path.GetFileName(depPath));
					if (File.Exists(text))
					{
						dependencyCache[depIdx] = am.LoadAssetsFile(text, loadDeps: true);
					}
					else if (File.Exists(text2))
					{
						dependencyCache[depIdx] = am.LoadAssetsFile(text2, loadDeps: true);
					}
					else
					{
						if (parentBundle == null)
						{
							return null;
						}
						AssetBundleFile assetBundleFile = parentBundle.file;
						if (assetBundleFile.BlockAndDirInfo.DirectoryInfos.Any((AssetBundleDirectoryInfo di) => di.Name == depPath))
						{
							dependencyCache[depIdx] = am.LoadAssetsFileFromBundle(parentBundle, depPath, loadDeps: true);
						}
						else
						{
							string directoryName2 = Path.GetDirectoryName(directoryName);
							string text3 = Path.Combine(directoryName2, Path.GetFileName(depPath));
							if (!File.Exists(text3))
							{
								return null;
							}
							dependencyCache[depIdx] = am.LoadAssetsFile(text3, loadDeps: true);
						}
					}
				}
				else
				{
					dependencyCache[depIdx] = value;
				}
			}
			return dependencyCache[depIdx];
		}
	}
	public class AssetsManager
	{
		private readonly Dictionary<int, AssetTypeTemplateField> templateFieldCache = new Dictionary<int, AssetTypeTemplateField>();

		private readonly Dictionary<AssetTypeReference, AssetTypeTemplateField> monoTemplateFieldCache = new Dictionary<AssetTypeReference, AssetTypeTemplateField>();

		private readonly Dictionary<AssetsFileInstance, Dictionary<ushort, AssetTypeTemplateField>> monoTypeTreeTemplateFieldCache = new Dictionary<AssetsFileInstance, Dictionary<ushort, AssetTypeTemplateField>>();

		private readonly Dictionary<AssetsFileInstance, Dictionary<long, AssetTypeTemplateField>> monoCldbTemplateFieldCache = new Dictionary<AssetsFileInstance, Dictionary<long, AssetTypeTemplateField>>();

		private readonly Dictionary<AssetsFileInstance, RefTypeManager> refTypeManagerCache = new Dictionary<AssetsFileInstance, RefTypeManager>();

		public bool UseTemplateFieldCache { get; set; } = false;


		public bool UseMonoTemplateFieldCache { get; set; } = false;


		public bool UseRefTypeManagerCache { get; set; } = false;


		public bool UseQuickLookup { get; set; } = false;


		public ClassDatabaseFile ClassDatabase { get; private set; }

		public ClassPackageFile ClassPackage { get; private set; }

		public List<AssetsFileInstance> Files { get; private set; } = new List<AssetsFileInstance>();


		public Dictionary<string, AssetsFileInstance> FileLookup { get; private set; } = new Dictionary<string, AssetsFileInstance>();


		public List<BundleFileInstance> Bundles { get; private set; } = new List<BundleFileInstance>();


		public Dictionary<string, BundleFileInstance> BundleLookup { get; private set; } = new Dictionary<string, BundleFileInstance>();


		public IMonoBehaviourTemplateGenerator MonoTempGenerator { get; set; } = null;


		internal string GetFileLookupKey(string path)
		{
			return Path.GetFileName(path).ToLower();
		}

		private void LoadAssetsFileDependencies(AssetsFileInstance fileInst, string path, BundleFileInstance bunInst)
		{
			if (bunInst == null)
			{
				LoadDependencies(fileInst);
			}
			else
			{
				LoadBundleDependencies(fileInst, bunInst, Path.GetDirectoryName(path));
			}
		}

		private AssetsFileInstance LoadAssetsFileCacheless(Stream stream, string path, bool loadDeps, BundleFileInstance bunInst = null)
		{
			AssetsFileInstance assetsFileInstance = new AssetsFileInstance(stream, path);
			assetsFileInstance.parentBundle = bunInst;
			string fileLookupKey = GetFileLookupKey(path);
			FileLookup[fileLookupKey] = assetsFileInstance;
			Files.Add(assetsFileInstance);
			if (loadDeps)
			{
				LoadAssetsFileDependencies(assetsFileInstance, path, bunInst);
			}
			if (UseQuickLookup)
			{
				assetsFileInstance.file.GenerateQuickLookup();
			}
			return assetsFileInstance;
		}

		public AssetsFileInstance LoadAssetsFile(Stream stream, string path, bool loadDeps = false, BundleFileInstance bunInst = null)
		{
			string fileLookupKey = GetFileLookupKey(path);
			if (FileLookup.TryGetValue(fileLookupKey, out var value))
			{
				if (loadDeps)
				{
					LoadAssetsFileDependencies(value, path, bunInst);
				}
				return value;
			}
			return LoadAssetsFileCacheless(stream, path, loadDeps, bunInst);
		}

		public AssetsFileInstance LoadAssetsFile(FileStream stream, bool loadDeps = false)
		{
			return LoadAssetsFile(stream, stream.Name, loadDeps);
		}

		public AssetsFileInstance LoadAssetsFile(string path, bool loadDeps = false)
		{
			string fileLookupKey = GetFileLookupKey(path);
			if (FileLookup.TryGetValue(fileLookupKey, out var value))
			{
				return value;
			}
			FileStream fileStream = File.OpenRead(path);
			return LoadAssetsFileCacheless(fileStream, fileStream.Name, loadDeps);
		}

		public bool UnloadAssetsFile(string path)
		{
			string fileLookupKey = GetFileLookupKey(path);
			if (FileLookup.TryGetValue(fileLookupKey, out var value))
			{
				monoTypeTreeTemplateFieldCache.Remove(value);
				monoCldbTemplateFieldCache.Remove(value);
				refTypeManagerCache.Remove(value);
				Files.Remove(value);
				FileLookup.Remove(fileLookupKey);
				value.file.Close();
				return true;
			}
			return false;
		}

		public bool UnloadAssetsFile(AssetsFileInstance fileInst)
		{
			fileInst.file.Close();
			if (Files.Contains(fileInst))
			{
				monoTypeTreeTemplateFieldCache.Remove(fileInst);
				monoCldbTemplateFieldCache.Remove(fileInst);
				refTypeManagerCache.Remove(fileInst);
				string fileLookupKey = GetFileLookupKey(fileInst.path);
				FileLookup.Remove(fileLookupKey);
				Files.Remove(fileInst);
				return true;
			}
			return false;
		}

		public bool UnloadAllAssetsFiles(bool clearCache = false)
		{
			if (clearCache)
			{
				templateFieldCache.Clear();
				monoTemplateFieldCache.Clear();
			}
			monoTypeTreeTemplateFieldCache.Clear();
			monoCldbTemplateFieldCache.Clear();
			refTypeManagerCache.Clear();
			if (Files.Count != 0)
			{
				foreach (AssetsFileInstance file in Files)
				{
					file.file.Close();
				}
				Files.Clear();
				FileLookup.Clear();
				return true;
			}
			return false;
		}

		public BundleFileInstance LoadBundleFile(Stream stream, string path, bool unpackIfPacked = true)
		{
			string fileLookupKey = GetFileLookupKey(path);
			if (BundleLookup.TryGetValue(fileLookupKey, out var value))
			{
				return value;
			}
			value = new BundleFileInstance(stream, path, unpackIfPacked);
			Bundles.Add(value);
			BundleLookup[fileLookupKey] = value;
			return value;
		}

		public BundleFileInstance LoadBundleFile(FileStream stream, bool unpackIfPacked = true)
		{
			return LoadBundleFile(stream, Path.GetFullPath(stream.Name), unpackIfPacked);
		}

		public BundleFileInstance LoadBundleFile(string path, bool unpackIfPacked = true)
		{
			return LoadBundleFile(File.OpenRead(path), unpackIfPacked);
		}

		public bool UnloadBundleFile(string path)
		{
			string fileLookupKey = GetFileLookupKey(path);
			if (BundleLookup.TryGetValue(fileLookupKey, out var value))
			{
				value.file.Close();
				foreach (AssetsFileInstance loadedAssetsFile in value.loadedAssetsFiles)
				{
					loadedAssetsFile.file.Close();
				}
				Bundles.Remove(value);
				BundleLookup.Remove(fileLookupKey);
				return true;
			}
			return false;
		}

		public bool UnloadBundleFile(BundleFileInstance bunInst)
		{
			bunInst.file.Close();
			foreach (AssetsFileInstance loadedAssetsFile in bunInst.loadedAssetsFiles)
			{
				UnloadAssetsFile(loadedAssetsFile);
			}
			bunInst.loadedAssetsFiles.Clear();
			if (Bundles.Contains(bunInst))
			{
				string fileLookupKey = GetFileLookupKey(bunInst.path);
				BundleLookup.Remove(fileLookupKey);
				Bundles.Remove(bunInst);
				return true;
			}
			return false;
		}

		public bool UnloadAllBundleFiles()
		{
			if (Bundles.Count != 0)
			{
				foreach (BundleFileInstance bundle in Bundles)
				{
					bundle.file.Close();
					foreach (AssetsFileInstance loadedAssetsFile in bundle.loadedAssetsFiles)
					{
						UnloadAssetsFile(loadedAssetsFile);
					}
					bundle.loadedAssetsFiles.Clear();
				}
				Bundles.Clear();
				BundleLookup.Clear();
				return true;
			}
			return false;
		}

		private bool IsAssetsFilePreviewSafe(BundleFileInstance bunInst, int index)
		{
			AssetBundleDirectoryInfo dirInfo = BundleHelper.GetDirInfo(bunInst.file, index);
			if (dirInfo.IsReplacerPreviewable)
			{
				Stream previewStream = dirInfo.Replacer.GetPreviewStream();
				return AssetsFile.IsAssetsFile(new AssetsFileReader(previewStream), 0L, previewStream.Length);
			}
			return bunInst.file.IsAssetsFile(index);
		}

		public AssetsFileInstance LoadAssetsFileFromBundle(BundleFileInstance bunInst, int index, bool loadDeps = false)
		{
			string path = Path.Combine(bunInst.path, bunInst.file.GetFileName(index));
			string fileLookupKey = GetFileLookupKey(path);
			if (!FileLookup.TryGetValue(fileLookupKey, out var value))
			{
				if (IsAssetsFilePreviewSafe(bunInst, index))
				{
					bunInst.file.GetFileRange(index, out var offset, out var length);
					SegmentStream stream = new SegmentStream(bunInst.DataStream, offset, length);
					AssetsFileInstance assetsFileInstance = LoadAssetsFile(stream, path, loadDeps, bunInst);
					bunInst.loadedAssetsFiles.Add(assetsFileInstance);
					return assetsFileInstance;
				}
				return null;
			}
			return value;
		}

		public AssetsFileInstance LoadAssetsFileFromBundle(BundleFileInstance bunInst, string name, bool loadDeps = false)
		{
			int fileIndex = bunInst.file.GetFileIndex(name);
			if (fileIndex < 0)
			{
				return null;
			}
			return LoadAssetsFileFromBundle(bunInst, fileIndex, loadDeps);
		}

		public ClassDatabaseFile LoadClassDatabase(Stream stream)
		{
			ClassDatabase = new ClassDatabaseFile();
			ClassDatabase.Read(new AssetsFileReader(stream));
			return ClassDatabase;
		}

		public ClassDatabaseFile LoadClassDatabase(string path)
		{
			return LoadClassDatabase(File.OpenRead(path));
		}

		public ClassDatabaseFile LoadClassDatabaseFromPackage(UnityVersion version)
		{
			return ClassDatabase = ClassPackage.GetClassDatabase(version);
		}

		public ClassDatabaseFile LoadClassDatabaseFromPackage(string version)
		{
			return ClassDatabase = ClassPackage.GetClassDatabase(version);
		}

		public ClassPackageFile LoadClassPackage(Stream stream)
		{
			ClassPackage = new ClassPackageFile();
			ClassPackage.Read(new AssetsFileReader(stream));
			return ClassPackage;
		}

		public ClassPackageFile LoadClassPackage(string path)
		{
			return LoadClassPackage(File.OpenRead(path));
		}

		public void UnloadAll(bool unloadClassData = false)
		{
			UnloadAllAssetsFiles(clearCache: true);
			UnloadAllBundleFiles();
			MonoTempGenerator?.Dispose();
			if (unloadClassData)
			{
				ClassPackage = null;
				ClassDatabase = null;
			}
		}

		public void LoadDependencies(AssetsFileInstance ofFile)
		{
			string directoryName = Path.GetDirectoryName(ofFile.path);
			for (int i = 0; i < ofFile.file.Metadata.Externals.Count; i++)
			{
				string depPath = ofFile.file.Metadata.Externals[i].PathName;
				if (!(depPath == string.Empty) && Files.FindIndex((AssetsFileInstance f) => Path.GetFileName(f.path).ToLower() == Path.GetFileName(depPath).ToLower()) == -1)
				{
					string path = Path.Combine(directoryName, depPath);
					string path2 = Path.Combine(directoryName, Path.GetFileName(depPath));
					if (File.Exists(path))
					{
						LoadAssetsFile(path, loadDeps: true);
					}
					else if (File.Exists(path2))
					{
						LoadAssetsFile(path2, loadDeps: true);
					}
				}
			}
		}

		public void LoadBundleDependencies(AssetsFileInstance ofFile, BundleFileInstance ofBundle, string path)
		{
			for (int i = 0; i < ofFile.file.Metadata.Externals.Count; i++)
			{
				string depPath = ofFile.file.Metadata.Externals[i].PathName;
				if (Files.FindIndex((AssetsFileInstance f) => Path.GetFileName(f.path).ToLower() == Path.GetFileName(depPath).ToLower()) == -1)
				{
					string bunPath = Path.GetFileName(depPath);
					int num = ofBundle.file.BlockAndDirInfo.DirectoryInfos.FindIndex((AssetBundleDirectoryInfo d) => Path.GetFileName(d.Name) == bunPath);
					string path2 = Path.Combine(path, "..");
					string path3 = Path.Combine(path2, depPath);
					string path4 = Path.Combine(path2, Path.GetFileName(depPath));
					string path5 = Path.Combine(path, depPath);
					string path6 = Path.Combine(path, Path.GetFileName(depPath));
					if (num != -1)
					{
						LoadAssetsFileFromBundle(ofBundle, num, loadDeps: true);
					}
					else if (File.Exists(path5))
					{
						LoadAssetsFile(path5, loadDeps: true);
					}
					else if (File.Exists(path6))
					{
						LoadAssetsFile(path6, loadDeps: true);
					}
					else if (File.Exists(path3))
					{
						LoadAssetsFile(path3, loadDeps: true);
					}
					else if (File.Exists(path4))
					{
						LoadAssetsFile(path4, loadDeps: true);
					}
				}
			}
		}

		public RefTypeManager GetRefTypeManager(AssetsFileInstance inst)
		{
			if (UseRefTypeManagerCache && refTypeManagerCache.TryGetValue(inst, out var value))
			{
				return value;
			}
			value = new RefTypeManager();
			value.FromTypeTree(inst.file.Metadata);
			if (MonoTempGenerator != null)
			{
				value.WithMonoTemplateGenerator(inst.file.Metadata, MonoTempGenerator, UseMonoTemplateFieldCache ? monoTemplateFieldCache : null);
			}
			if (UseRefTypeManagerCache)
			{
				refTypeManagerCache[inst] = value;
			}
			return value;
		}

		public AssetTypeTemplateField GetTemplateBaseField(AssetsFileInstance inst, AssetFileInfo info, AssetReadFlags readFlags = AssetReadFlags.None)
		{
			ushort scriptIndex = inst.file.GetScriptIndex(info);
			if (info.ReplacerType != ContentReplacerType.AddOrModify)
			{
				long absoluteByteOffset = info.GetAbsoluteByteOffset(inst.file);
				return GetTemplateBaseField(inst, inst.file.Reader, absoluteByteOffset, info.TypeId, scriptIndex, readFlags);
			}
			if (info.Replacer.HasPreview())
			{
				Stream previewStream = info.Replacer.GetPreviewStream();
				AssetsFileReader reader = new AssetsFileReader(previewStream);
				return GetTemplateBaseField(inst, reader, 0L, info.TypeId, scriptIndex, readFlags);
			}
			return GetTemplateBaseField(inst, null, 0L, info.TypeId, scriptIndex, readFlags);
		}

		public AssetTypeTemplateField GetTemplateBaseField(AssetsFileInstance inst, AssetsFileReader reader, long absByteStart, int typeId, ushort scriptIndex, AssetReadFlags readFlags)
		{
			AssetsFile file = inst.file;
			AssetTypeTemplateField value = null;
			bool typeTreeEnabled = inst.file.Metadata.TypeTreeEnabled;
			bool preferEditor = Net35Polyfill.HasFlag(readFlags, AssetReadFlags.PreferEditor);
			bool flag = Net35Polyfill.HasFlag(readFlags, AssetReadFlags.ForceFromCldb);
			bool flag2 = Net35Polyfill.HasFlag(readFlags, AssetReadFlags.SkipMonoBehaviourFields);
			if (UseTemplateFieldCache && typeId != 114 && templateFieldCache.TryGetValue(typeId, out value))
			{
				return value;
			}
			if (typeTreeEnabled && !flag)
			{
				if (UseMonoTemplateFieldCache && typeId == 114 && monoTypeTreeTemplateFieldCache.TryGetValue(inst, out var value2) && value2.TryGetValue(scriptIndex, out var value3))
				{
					return value3;
				}
				TypeTreeType typeTreeType = file.Metadata.FindTypeTreeTypeByID(typeId, scriptIndex);
				if (typeTreeType != null && typeTreeType.Nodes.Count > 0)
				{
					value = new AssetTypeTemplateField();
					value.FromTypeTree(typeTreeType);
					if (UseTemplateFieldCache && typeId != 114)
					{
						templateFieldCache[typeId] = value;
					}
					else if (UseMonoTemplateFieldCache && (long)typeId == 114)
					{
						if (!monoTypeTreeTemplateFieldCache.TryGetValue(inst, out var value4))
						{
							value4 = (monoTypeTreeTemplateFieldCache[inst] = new Dictionary<ushort, AssetTypeTemplateField>());
						}
						value4[scriptIndex] = value;
					}
					return value;
				}
			}
			if (UseTemplateFieldCache && UseMonoTemplateFieldCache && typeId == 114 && templateFieldCache.TryGetValue(typeId, out value))
			{
				value = value.Clone();
			}
			if (value == null)
			{
				ClassDatabaseType classDatabaseType = ClassDatabase.FindAssetClassByID(typeId);
				if (classDatabaseType == null)
				{
					return null;
				}
				value = new AssetTypeTemplateField();
				value.FromClassDatabase(ClassDatabase, classDatabaseType, preferEditor);
				if (UseTemplateFieldCache)
				{
					if (typeId == 114)
					{
						templateFieldCache[typeId] = value.Clone();
					}
					else
					{
						templateFieldCache[typeId] = value;
					}
				}
			}
			if (typeId == 114 && MonoTempGenerator != null && !flag2 && reader != null)
			{
				AssetTypeValueField assetTypeValueField = value.MakeValue(reader, absByteStart);
				AssetPPtr assetPPtr = AssetPPtr.FromField(assetTypeValueField["m_Script"]);
				if (!assetPPtr.IsNull())
				{
					AssetsFileInstance assetsFileInstance = ((assetPPtr.FileId != 0) ? inst.GetDependency(this, assetPPtr.FileId - 1) : inst);
					if (assetsFileInstance == null)
					{
						return value;
					}
					Dictionary<long, AssetTypeTemplateField> value5 = null;
					if (UseMonoTemplateFieldCache)
					{
						AssetTypeTemplateField value6;
						if (!monoCldbTemplateFieldCache.TryGetValue(assetsFileInstance, out value5))
						{
							value5 = (monoCldbTemplateFieldCache[assetsFileInstance] = new Dictionary<long, AssetTypeTemplateField>());
						}
						else if (value5.TryGetValue(assetPPtr.PathId, out value6))
						{
							return value6;
						}
					}
					AssetFileInfo assetInfo = assetsFileInstance.file.GetAssetInfo(assetPPtr.PathId);
					long absoluteByteOffset = assetInfo.GetAbsoluteByteOffset(assetsFileInstance.file);
					int typeId2 = assetInfo.TypeId;
					ushort scriptIndex2 = assetsFileInstance.file.GetScriptIndex(assetInfo);
					string assemblyName;
					string nameSpace;
					string className;
					bool monoScriptInfo = GetMonoScriptInfo(assetsFileInstance, absoluteByteOffset, typeId2, scriptIndex2, out assemblyName, out nameSpace, out className, readFlags);
					if (assemblyName.EndsWith(".dll"))
					{
						assemblyName = assemblyName.Substring(0, assemblyName.Length - 4);
					}
					if (monoScriptInfo)
					{
						AssetTypeReference key = new AssetTypeReference(className, nameSpace, assemblyName);
						if (UseMonoTemplateFieldCache && monoTemplateFieldCache.TryGetValue(key, out var value7))
						{
							value5[assetPPtr.PathId] = value7;
							return value7;
						}
						AssetTypeTemplateField templateField = MonoTempGenerator.GetTemplateField(value, assemblyName, nameSpace, className, new UnityVersion(file.Metadata.UnityVersion));
						if (templateField != null)
						{
							value = templateField;
							if (UseMonoTemplateFieldCache)
							{
								Dictionary<long, AssetTypeTemplateField> dictionary3 = value5;
								long pathId = assetPPtr.PathId;
								AssetTypeTemplateField value8 = (monoTemplateFieldCache[key] = value);
								dictionary3[pathId] = value8;
								return value;
							}
						}
					}
				}
			}
			return value;
		}

		private bool GetMonoScriptInfo(AssetsFileInstance inst, long absFilePos, int typeId, ushort scriptIndex, out string assemblyName, out string nameSpace, out string className, AssetReadFlags readFlags)
		{
			assemblyName = null;
			nameSpace = null;
			className = null;
			AssetTypeTemplateField templateBaseField = GetTemplateBaseField(inst, null, absFilePos, typeId, scriptIndex, readFlags);
			if (templateBaseField == null)
			{
				return false;
			}
			inst.file.Reader.Position = absFilePos;
			AssetTypeValueField assetTypeValueField = templateBaseField.MakeValue(inst.file.Reader);
			assemblyName = assetTypeValueField["m_AssemblyName"].AsString;
			nameSpace = assetTypeValueField["m_Namespace"].AsString;
			className = assetTypeValueField["m_ClassName"].AsString;
			return true;
		}

		public AssetTypeTemplateField CreateTemplateBaseField(AssetsFileInstance inst, int id, ushort scriptIndex = ushort.MaxValue)
		{
			AssetsFile file = inst.file;
			AssetTypeTemplateField assetTypeTemplateField = new AssetTypeTemplateField();
			if (file.Metadata.TypeTreeEnabled)
			{
				TypeTreeType typeTreeType = file.Metadata.FindTypeTreeTypeByID(id, scriptIndex);
				assetTypeTemplateField.FromTypeTree(typeTreeType);
			}
			else if (id != 114 || scriptIndex == ushort.MaxValue)
			{
				ClassDatabaseType cldbType = ClassDatabase.FindAssetClassByID(id);
				assetTypeTemplateField.FromClassDatabase(ClassDatabase, cldbType);
			}
			else
			{
				if (MonoTempGenerator == null)
				{
					throw new Exception("MonoTempGenerator must be non-null to create a MonoBehaviour!");
				}
				AssetTypeReference assetsFileScriptInfo = AssetHelper.GetAssetsFileScriptInfo(this, inst, scriptIndex);
				AssetTypeTemplateField templateBaseField = GetTemplateBaseField(inst, file.Reader, -1L, 114, scriptIndex, AssetReadFlags.SkipMonoBehaviourFields);
				UnityVersion unityVersion = new UnityVersion(file.Metadata.UnityVersion);
				assetTypeTemplateField = MonoTempGenerator.GetTemplateField(templateBaseField, assetsFileScriptInfo.AsmName, assetsFileScriptInfo.Namespace, assetsFileScriptInfo.ClassName, unityVersion);
			}
			return assetTypeTemplateField;
		}

		public AssetTypeValueField CreateValueBaseField(AssetsFileInstance inst, int id, ushort scriptIndex = ushort.MaxValue)
		{
			AssetTypeTemplateField templateField = CreateTemplateBaseField(inst, id, scriptIndex);
			return ValueBuilder.DefaultValueFieldFromTemplate(templateField);
		}

		public AssetTypeValueField GetBaseField(AssetsFileInstance inst, AssetFileInfo info, AssetReadFlags readFlags = AssetReadFlags.None)
		{
			AssetTypeTemplateField templateBaseField = GetTemplateBaseField(inst, info, readFlags);
			RefTypeManager refTypeManager = GetRefTypeManager(inst);
			if (info.IsReplacerPreviewable)
			{
				Stream previewStream = info.Replacer.GetPreviewStream();
				return templateBaseField.MakeValue(new AssetsFileReader(previewStream), 0L, refTypeManager);
			}
			return templateBaseField.MakeValue(inst.file.Reader, info.GetAbsoluteByteOffset(inst.file), refTypeManager);
		}

		public AssetTypeValueField GetBaseField(AssetsFileInstance inst, long pathId, AssetReadFlags readFlags = AssetReadFlags.None)
		{
			AssetFileInfo assetInfo = inst.file.GetAssetInfo(pathId);
			return GetBaseField(inst, assetInfo, readFlags);
		}

		public AssetExternal GetExtAsset(AssetsFileInstance relativeTo, int fileId, long pathId, bool onlyGetInfo = false, AssetReadFlags readFlags = AssetReadFlags.None)
		{
			AssetExternal assetExternal = default(AssetExternal);
			assetExternal.info = null;
			assetExternal.baseField = null;
			assetExternal.file = null;
			AssetExternal result = assetExternal;
			if (fileId == 0 && pathId == 0)
			{
				return result;
			}
			if (fileId != 0)
			{
				AssetsFileInstance dependency = relativeTo.GetDependency(this, fileId - 1);
				if (dependency == null)
				{
					return result;
				}
				result.file = dependency;
				result.info = dependency.file.GetAssetInfo(pathId);
				if (result.info == null)
				{
					return result;
				}
				if (!onlyGetInfo)
				{
					result.baseField = GetBaseField(dependency, result.info, readFlags);
				}
				else
				{
					result.baseField = null;
				}
				return result;
			}
			result.file = relativeTo;
			result.info = relativeTo.file.GetAssetInfo(pathId);
			if (result.info == null)
			{
				return result;
			}
			if (!onlyGetInfo)
			{
				result.baseField = GetBaseField(relativeTo, result.info, readFlags);
			}
			else
			{
				result.baseField = null;
			}
			return result;
		}

		public AssetExternal GetExtAsset(AssetsFileInstance relativeTo, AssetTypeValueField pptrField, bool onlyGetInfo = false, AssetReadFlags readFlags = AssetReadFlags.None)
		{
			int asInt = pptrField["m_FileID"].AsInt;
			long asLong = pptrField["m_PathID"].AsLong;
			return GetExtAsset(relativeTo, asInt, asLong, onlyGetInfo, readFlags);
		}
	}
	public struct AssetExternal
	{
		public AssetFileInfo info;

		public AssetTypeValueField baseField;

		public AssetsFileInstance file;
	}
	public class BundleFileInstance
	{
		public string path;

		public string name;

		public AssetBundleFile file;

		public List<AssetsFileInstance> loadedAssetsFiles;

		public Stream BundleStream => file.Reader.BaseStream;

		public Stream DataStream => file.DataReader.BaseStream;

		public BundleFileInstance(Stream stream, string filePath, bool unpackIfPacked = true)
		{
			path = Path.GetFullPath(filePath);
			name = Path.GetFileName(path);
			file = new AssetBundleFile();
			file.Read(new AssetsFileReader(stream));
			if (file.Header != null && file.DataIsCompressed && unpackIfPacked)
			{
				file = BundleHelper.UnpackBundle(file);
			}
			loadedAssetsFiles = new List<AssetsFileInstance>();
		}

		public BundleFileInstance(FileStream stream, bool unpackIfPacked = true)
			: this(stream, stream.Name, unpackIfPacked)
		{
		}
	}
	public interface IMonoBehaviourTemplateGenerator
	{
		AssetTypeTemplateField GetTemplateField(AssetTypeTemplateField baseField, string assemblyName, string nameSpace, string className, UnityVersion unityVersion);

		void Dispose();
	}
	public class BundleCreator
	{
		public static void CreateBlankAssets(MemoryStream ms, string engineVersion, uint formatVersion, uint typeTreeVersion, bool hasTypeTree = false)
		{
			AssetsFileWriter assetsFileWriter = new AssetsFileWriter(ms);
			AssetsFileHeader assetsFileHeader = new AssetsFileHeader
			{
				MetadataSize = 0L,
				FileSize = -1L,
				Version = formatVersion,
				DataOffset = -1L,
				Endianness = false
			};
			AssetsFileMetadata assetsFileMetadata = new AssetsFileMetadata
			{
				UnityVersion = engineVersion,
				TargetPlatform = typeTreeVersion,
				TypeTreeEnabled = hasTypeTree,
				TypeTreeTypes = new List<TypeTreeType>(),
				AssetInfos = new List<AssetFileInfo>(),
				ScriptTypes = new List<AssetPPtr>(),
				Externals = new List<AssetsFileExternal>(),
				RefTypes = new List<TypeTreeType>()
			};
			assetsFileHeader.Write(assetsFileWriter);
			assetsFileMetadata.Write(assetsFileWriter, formatVersion);
			assetsFileWriter.Write(0u);
			assetsFileWriter.Align();
			assetsFileWriter.Write(0u);
			assetsFileWriter.Write(0u);
			if (assetsFileHeader.Version >= 20)
			{
				assetsFileWriter.Write(0);
			}
			uint num = (uint)(assetsFileWriter.Position - 19);
			if (assetsFileHeader.Version >= 22)
			{
				num -= 28;
			}
			if (assetsFileWriter.Position < 4096)
			{
				while (assetsFileWriter.Position < 4096)
				{
					assetsFileWriter.Write((byte)0);
				}
			}
			else if (assetsFileWriter.Position % 16 == 0)
			{
				assetsFileWriter.Position += 16L;
			}
			else
			{
				assetsFileWriter.Align16();
			}
			long position2 = (assetsFileHeader.DataOffset = (assetsFileHeader.FileSize = assetsFileWriter.Position));
			assetsFileHeader.MetadataSize = num;
			assetsFileWriter.Position = 0L;
			assetsFileHeader.Write(assetsFileWriter);
			assetsFileWriter.Position = position2;
		}
	}
	public static class BundleHelper
	{
		public static byte[] LoadAssetDataFromBundle(AssetBundleFile bundle, int index)
		{
			bundle.GetFileRange(index, out var offset, out var length);
			AssetsFileReader dataReader = bundle.DataReader;
			dataReader.Position = offset;
			return dataReader.ReadBytes((int)length);
		}

		public static byte[] LoadAssetDataFromBundle(AssetBundleFile bundle, string name)
		{
			int fileIndex = bundle.GetFileIndex(name);
			if (fileIndex < 0)
			{
				return null;
			}
			return LoadAssetDataFromBundle(bundle, fileIndex);
		}

		public static AssetsFile LoadAssetFromBundle(AssetBundleFile bundle, int index)
		{
			bundle.GetFileRange(index, out var offset, out var length);
			Stream stream = new SegmentStream(bundle.DataReader.BaseStream, offset, length);
			AssetsFileReader reader = new AssetsFileReader(stream);
			AssetsFile assetsFile = new AssetsFile();
			assetsFile.Read(reader);
			return assetsFile;
		}

		public static AssetsFile LoadAssetFromBundle(AssetBundleFile bundle, string name)
		{
			int fileIndex = bundle.GetFileIndex(name);
			if (fileIndex < 0)
			{
				return null;
			}
			return LoadAssetFromBundle(bundle, fileIndex);
		}

		public static List<byte[]> LoadAllAssetsDataFromBundle(AssetBundleFile bundle)
		{
			List<byte[]> list = new List<byte[]>();
			int count = bundle.BlockAndDirInfo.DirectoryInfos.Count;
			for (int i = 0; i < count; i++)
			{
				if (bundle.IsAssetsFile(i))
				{
					list.Add(LoadAssetDataFromBundle(bundle, i));
				}
			}
			return list;
		}

		public static List<AssetsFile> LoadAllAssetsFromBundle(AssetBundleFile bundle)
		{
			List<AssetsFile> list = new List<AssetsFile>();
			int count = bundle.BlockAndDirInfo.DirectoryInfos.Count;
			for (int i = 0; i < count; i++)
			{
				if (bundle.IsAssetsFile(i))
				{
					list.Add(LoadAssetFromBundle(bundle, i));
				}
			}
			return list;
		}

		public static AssetBundleFile UnpackBundle(AssetBundleFile file, bool freeOriginalStream = true)
		{
			MemoryStream memoryStream = new MemoryStream();
			file.Unpack(new AssetsFileWriter(memoryStream));
			memoryStream.Position = 0L;
			AssetBundleFile assetBundleFile = new AssetBundleFile();
			assetBundleFile.Read(new AssetsFileReader(memoryStream));
			if (freeOriginalStream)
			{
				file.Reader.Close();
				file.DataReader.Close();
			}
			return assetBundleFile;
		}

		public static AssetBundleFile UnpackBundleToStream(AssetBundleFile file, Stream stream, bool freeOriginalStream = true)
		{
			file.Unpack(new AssetsFileWriter(stream));
			stream.Position = 0L;
			AssetBundleFile assetBundleFile = new AssetBundleFile();
			assetBundleFile.Read(new AssetsFileReader(stream));
			if (freeOriginalStream)
			{
				file.Reader.Close();
				file.DataReader.Close();
			}
			return assetBundleFile;
		}

		public static AssetBundleDirectoryInfo GetDirInfo(AssetBundleFile bundle, int index)
		{
			List<AssetBundleDirectoryInfo> directoryInfos = bundle.BlockAndDirInfo.DirectoryInfos;
			return directoryInfos[index];
		}

		public static AssetBundleDirectoryInfo GetDirInfo(AssetBundleFile bundle, string name)
		{
			List<AssetBundleDirectoryInfo> directoryInfos = bundle.BlockAndDirInfo.DirectoryInfos;
			for (int i = 0; i < directoryInfos.Count; i++)
			{
				AssetBundleDirectoryInfo assetBundleDirectoryInfo = directoryInfos[i];
				if (assetBundleDirectoryInfo.Name == name)
				{
					return assetBundleDirectoryInfo;
				}
			}
			return null;
		}
	}
	public class ClassDatabaseToTypeTree
	{
		private ClassDatabaseFile cldbFile;

		private uint stringTablePos;

		private Dictionary<string, uint> stringTableLookup;

		private Dictionary<string, uint> commonStringTableLookup;

		private List<TypeTreeNode> typeTreeNodes;

		public static TypeTreeType Convert(ClassDatabaseFile classes, string name, bool preferEditor = false)
		{
			ClassDatabaseType classDatabaseType = classes.FindAssetClassByName(name);
			if (classDatabaseType == null)
			{
				return null;
			}
			return Convert(classes, classDatabaseType, preferEditor);
		}

		public static TypeTreeType Convert(ClassDatabaseFile classes, int id, bool preferEditor = false)
		{
			ClassDatabaseType classDatabaseType = classes.FindAssetClassByID(id);
			if (classDatabaseType == null)
			{
				return null;
			}
			return Convert(classes, classDatabaseType, preferEditor);
		}

		public static TypeTreeType Convert(ClassDatabaseFile classes, ClassDatabaseType type, bool preferEditor = false)
		{
			ClassDatabaseToTypeTree classDatabaseToTypeTree = new ClassDatabaseToTypeTree();
			return classDatabaseToTypeTree.ConvertInternal(classes, type, preferEditor);
		}

		private TypeTreeType ConvertInternal(ClassDatabaseFile classes, ClassDatabaseType type, bool preferEditor = false)
		{
			TypeTreeType typeTreeType = new TypeTreeType();
			typeTreeType.TypeId = type.ClassId;
			typeTreeType.ScriptTypeIndex = ushort.MaxValue;
			typeTreeType.IsStrippedType = false;
			typeTreeType.ScriptIdHash = Hash128.NewBlankHash();
			typeTreeType.TypeHash = Hash128.NewBlankHash();
			typeTreeType.TypeDependencies = new int[0];
			TypeTreeType typeTreeType2 = typeTreeType;
			cldbFile = classes;
			stringTablePos = 0u;
			stringTableLookup = new Dictionary<string, uint>();
			commonStringTableLookup = new Dictionary<string, uint>();
			typeTreeNodes = new List<TypeTreeNode>();
			InitializeDefaultStringTableIndices();
			ClassDatabaseTypeNode preferredNode = type.GetPreferredNode(preferEditor);
			ConvertFields(preferredNode, 0);
			StringBuilder stringBuilder = new StringBuilder();
			List<KeyValuePair<string, uint>> list = stringTableLookup.OrderBy((KeyValuePair<string, uint> n) => n.Value).ToList();
			foreach (KeyValuePair<string, uint> item in list)
			{
				stringBuilder.Append(item.Key + "\0");
			}
			typeTreeType2.StringBuffer = stringBuilder.ToString();
			typeTreeType2.Nodes = typeTreeNodes;
			typeTreeType2.TypeHash = ComputeHash(typeTreeType2);
			return typeTreeType2;
		}

		private void InitializeDefaultStringTableIndices()
		{
			int num = 0;
			List<ushort> commonStringBufferIndices = cldbFile.CommonStringBufferIndices;
			foreach (ushort item in commonStringBufferIndices)
			{
				string @string = cldbFile.StringTable.GetString(item);
				if (@string != string.Empty)
				{
					commonStringTableLookup.Add(@string, (uint)num);
					num += @string.Length + 1;
				}
			}
		}

		private void ConvertFields(ClassDatabaseTypeNode node, int depth)
		{
			string @string = cldbFile.GetString(node.FieldName);
			string string2 = cldbFile.GetString(node.TypeName);
			uint nameStrOffset;
			if (stringTableLookup.ContainsKey(@string))
			{
				nameStrOffset = stringTableLookup[@string];
			}
			else if (commonStringTableLookup.ContainsKey(@string))
			{
				nameStrOffset = commonStringTableLookup[@string] + 2147483648u;
			}
			else
			{
				nameStrOffset = stringTablePos;
				stringTableLookup.Add(@string, stringTablePos);
				stringTablePos += (uint)(@string.Length + 1);
			}
			uint typeStrOffset;
			if (stringTableLookup.ContainsKey(string2))
			{
				typeStrOffset = stringTableLookup[string2];
			}
			else if (commonStringTableLookup.ContainsKey(string2))
			{
				typeStrOffset = commonStringTableLookup[string2] + 2147483648u;
			}
			else
			{
				typeStrOffset = stringTablePos;
				stringTableLookup.Add(string2, stringTablePos);
				stringTablePos += (uint)(string2.Length + 1);
			}
			typeTreeNodes.Add(new TypeTreeNode
			{
				Level = (byte)depth,
				MetaFlags = node.MetaFlag,
				Index = (uint)typeTreeNodes.Count,
				TypeFlags = (TypeTreeNodeFlags)node.TypeFlags,
				NameStrOffset = nameStrOffset,
				ByteSize = node.ByteSize,
				TypeStrOffset = typeStrOffset,
				Version = node.Version
			});
			foreach (ClassDatabaseTypeNode child in node.Children)
			{
				ConvertFields(child, depth + 1);
			}
		}

		private static Hash128 ComputeHash(TypeTreeType typeTree)
		{
			MD4 mD = new MD4();
			Update(typeTree, mD);
			return new Hash128(mD.Digest());
		}

		private static void Update(TypeTreeType typeTree, MD4 md4)
		{
			List<TypeTreeNode>.Enumerator enumerator = typeTree.Nodes.GetEnumerator();
			while (enumerator.MoveNext())
			{
				TypeTreeNode current = enumerator.Current;
				md4.Update(Encoding.UTF8.GetBytes(current.GetTypeString(typeTree.StringBufferBytes)));
				md4.Update(Encoding.UTF8.GetBytes(current.GetNameString(typeTree.StringBufferBytes)));
				md4.Update(BitConverter.GetBytes(current.ByteSize));
				md4.Update(BitConverter.GetBytes(System.Convert.ToInt32(current.TypeFlags)));
				md4.Update(BitConverter.GetBytes(System.Convert.ToInt32(current.Version)));
				md4.Update(BitConverter.GetBytes(System.Convert.ToInt32(current.MetaFlags & 0x4000u)));
			}
		}
	}
	public class MD4
	{
		private const int BLOCK_LENGTH = 64;

		private readonly uint[] X = new uint[16];

		private readonly uint[] context = new uint[4];

		private byte[] buffer = new byte[64];

		private long count;

		public MD4()
		{
			EngineReset();
		}

		private MD4(MD4 md)
			: this()
		{
			context = (uint[])md.context.Clone();
			buffer = (byte[])md.buffer.Clone();
			count = md.count;
		}

		public object Clone()
		{
			return new MD4(this);
		}

		public void Update(byte[] bytes)
		{
			EngineUpdate(bytes, 0, bytes.Length);
		}

		public byte[] Digest()
		{
			return EngineDigest();
		}

		private void EngineReset()
		{
			context[0] = 1732584193u;
			context[1] = 4023233417u;
			context[2] = 2562383102u;
			context[3] = 271733878u;
			count = 0L;
			for (int i = 0; i < 64; i++)
			{
				buffer[i] = 0;
			}
		}

		private void EngineUpdate(byte b)
		{
			int num = (int)(count % 64);
			count++;
			buffer[num] = b;
			if (num == 63)
			{
				Transform(ref buffer, 0);
			}
		}

		private void EngineUpdate(byte[] input, int offset, int len)
		{
			if (offset < 0 || len < 0 || (long)offset + (long)len > input.Length)
			{
				throw new ArgumentOutOfRangeException();
			}
			int num = (int)(count % 64);
			count += len;
			int num2 = 64 - num;
			int i = 0;
			if (len >= num2)
			{
				Array.Copy(input, offset + i, buffer, num, num2);
				Transform(ref buffer, 0);
				for (i = num2; i + 64 - 1 < len; i += 64)
				{
					Transform(ref input, offset + i);
				}
				num = 0;
			}
			if (i < len)
			{
				Array.Copy(input, offset + i, buffer, num, len - i);
			}
		}

		private byte[] EngineDigest()
		{
			int num = (int)(count % 64);
			int num2 = ((num < 56) ? (56 - num) : (120 - num));
			byte[] array = new byte[num2 + 8];
			array[0] = 128;
			for (int i = 0; i < 8; i++)
			{
				array[num2 + i] = (byte)(count * 8 >> 8 * i);
			}
			EngineUpdate(array, 0, array.Length);
			byte[] array2 = new byte[16];
			for (int j = 0; j < 4; j++)
			{
				for (int k = 0; k < 4; k++)
				{
					array2[j * 4 + k] = (byte)(context[j] >> 8 * k);
				}
			}
			EngineReset();
			return array2;
		}

		public byte[] GetByteHashFromString(string s)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			MD4 mD = new MD4();
			mD.EngineUpdate(bytes, 0, bytes.Length);
			return mD.EngineDigest();
		}

		public byte[] GetByteHashFromBytes(byte[] b)
		{
			MD4 mD = new MD4();
			mD.EngineUpdate(b, 0, b.Length);
			return mD.EngineDigest();
		}

		public string GetHexHashFromBytes(byte[] b)
		{
			byte[] byteHashFromBytes = GetByteHashFromBytes(b);
			return BytesToHex(byteHashFromBytes, byteHashFromBytes.Length);
		}

		public byte[] GetByteHashFromByte(byte b)
		{
			MD4 mD = new MD4();
			mD.EngineUpdate(b);
			return mD.EngineDigest();
		}

		public string GetHexHashFromByte(byte b)
		{
			byte[] byteHashFromByte = GetByteHashFromByte(b);
			return BytesToHex(byteHashFromByte, byteHashFromByte.Length);
		}

		public string GetHexHashFromString(string s)
		{
			byte[] byteHashFromString = GetByteHashFromString(s);
			return BytesToHex(byteHashFromString, byteHashFromString.Length);
		}

		private static string BytesToHex(byte[] a, int len)
		{
			string text = BitConverter.ToString(a);
			StringBuilder stringBuilder = new StringBuilder((len - 2) / 2);
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] != '-')
				{
					stringBuilder.Append(text[i]);
				}
			}
			return stringBuilder.ToString();
		}

		private void Transform(ref byte[] block, int offset)
		{
			for (int i = 0; i < 16; i++)
			{
				X[i] = (block[offset++] & 0xFFu) | (uint)((block[offset++] & 0xFF) << 8) | (uint)((block[offset++] & 0xFF) << 16) | (uint)((block[offset++] & 0xFF) << 24);
			}
			uint a = context[0];
			uint num = context[1];
			uint num2 = context[2];
			uint num3 = context[3];
			a = FF(a, num, num2, num3, X[0], 3);
			num3 = FF(num3, a, num, num2, X[1], 7);
			num2 = FF(num2, num3, a, num, X[2], 11);
			num = FF(num, num2, num3, a, X[3], 19);
			a = FF(a, num, num2, num3, X[4], 3);
			num3 = FF(num3, a, num, num2, X[5], 7);
			num2 = FF(num2, num3, a, num, X[6], 11);
			num = FF(num, num2, num3, a, X[7], 19);
			a = FF(a, num, num2, num3, X[8], 3);
			num3 = FF(num3, a, num, num2, X[9], 7);
			num2 = FF(num2, num3, a, num, X[10], 11);
			num = FF(num, num2, num3, a, X[11], 19);
			a = FF(a, num, num2, num3, X[12], 3);
			num3 = FF(num3, a, num, num2, X[13], 7);
			num2 = FF(num2, num3, a, num, X[14], 11);
			num = FF(num, num2, num3, a, X[15], 19);
			a = GG(a, num, num2, num3, X[0], 3);
			num3 = GG(num3, a, num, num2, X[4], 5);
			num2 = GG(num2, num3, a, num, X[8], 9);
			num = GG(num, num2, num3, a, X[12], 13);
			a = GG(a, num, num2, num3, X[1], 3);
			num3 = GG(num3, a, num, num2, X[5], 5);
			num2 = GG(num2, num3, a, num, X[9], 9);
			num = GG(num, num2, num3, a, X[13], 13);
			a = GG(a, num, num2, num3, X[2], 3);
			num3 = GG(num3, a, num, num2, X[6], 5);
			num2 = GG(num2, num3, a, num, X[10], 9);
			num = GG(num, num2, num3, a, X[14], 13);
			a = GG(a, num, num2, num3, X[3], 3);
			num3 = GG(num3, a, num, num2, X[7], 5);
			num2 = GG(num2, num3, a, num, X[11], 9);
			num = GG(num, num2, num3, a, X[15], 13);
			a = HH(a, num, num2, num3, X[0], 3);
			num3 = HH(num3, a, num, num2, X[8], 9);
			num2 = HH(num2, num3, a, num, X[4], 11);
			num = HH(num, num2, num3, a, X[12], 15);
			a = HH(a, num, num2, num3, X[2], 3);
			num3 = HH(num3, a, num, num2, X[10], 9);
			num2 = HH(num2, num3, a, num, X[6], 11);
			num = HH(num, num2, num3, a, X[14], 15);
			a = HH(a, num, num2, num3, X[1], 3);
			num3 = HH(num3, a, num, num2, X[9], 9);
			num2 = HH(num2, num3, a, num, X[5], 11);
			num = HH(num, num2, num3, a, X[13], 15);
			a = HH(a, num, num2, num3, X[3], 3);
			num3 = HH(num3, a, num, num2, X[11], 9);
			num2 = HH(num2, num3, a, num, X[7], 11);
			num = HH(num, num2, num3, a, X[15], 15);
			context[0] += a;
			context[1] += num;
			context[2] += num2;
			context[3] += num3;
		}

		private uint FF(uint a, uint b, uint c, uint d, uint x, int s)
		{
			uint num = a + ((b & c) | (~b & d)) + x;
			return (num << s) | (num >> 32 - s);
		}

		private uint GG(uint a, uint b, uint c, uint d, uint x, int s)
		{
			uint num = a + ((b & (c | d)) | (c & d)) + x + 1518500249;
			return (num << s) | (num >> 32 - s);
		}

		private uint HH(uint a, uint b, uint c, uint d, uint x, int s)
		{
			uint num = a + (b ^ c ^ d) + x + 1859775393;
			return (num << s) | (num >> 32 - s);
		}
	}
	public static class CommonMonoTemplateHelper
	{
		private static readonly string[] blacklistedAssemblies = new string[14]
		{
			"mscorlib", "mscorlib.dll", "netstandard", "netstandard.dll", "System.Core", "System.Core.dll", "System", "System.dll", "System.Private.CoreLib", "System.Private.CoreLib.dll",
			"System.Collections", "System.Collections.dll", "System.Collections.NonGeneric", "System.Collections.NonGeneric.dll"
		};

		private static readonly string[] specialUnityTypes = new string[18]
		{
			"UnityEngine.Color", "UnityEngine.Color32", "UnityEngine.Gradient", "UnityEngine.Vector2", "UnityEngine.Vector3", "UnityEngine.Vector4", "UnityEngine.LayerMask", "UnityEngine.Quaternion", "UnityEngine.Bounds", "UnityEngine.Rect",
			"UnityEngine.RectOffset", "UnityEngine.Matrix4x4", "UnityEngine.AnimationCurve", "UnityEngine.GUIStyle", "UnityEngine.Vector2Int", "UnityEngine.Vector3Int", "UnityEngine.PropertyName", "UnityEngine.BoundsInt"
		};

		private static readonly string[] primitiveTypes = new string[12]
		{
			"System.Boolean", "System.SByte", "System.Byte", "System.Char", "System.Int16", "System.UInt16", "System.Int32", "System.UInt32", "System.Int64", "System.UInt64",
			"System.Double", "System.Single"
		};

		private static readonly Dictionary<string, string> baseToPrimitive = new Dictionary<string, string>
		{
			["System.Boolean"] = "UInt8",
			["System.SByte"] = "SInt8",
			["System.Byte"] = "UInt8",
			["System.Char"] = "UInt16",
			["System.Int16"] = "SInt16",
			["System.UInt16"] = "UInt16",
			["System.Int32"] = "int",
			["System.UInt32"] = "unsigned int",
			["System.Int64"] = "SInt64",
			["System.UInt64"] = "UInt64",
			["System.Double"] = "double",
			["System.Single"] = "float",
			["System.String"] = "string"
		};

		private static readonly Dictionary<string, AssetValueType> baseToAssetValueType = new Dictionary<string, AssetValueType>
		{
			["System.Boolean"] = AssetValueType.UInt8,
			["System.SByte"] = AssetValueType.Int8,
			["System.Byte"] = AssetValueType.UInt8,
			["System.Char"] = AssetValueType.UInt16,
			["System.Int16"] = AssetValueType.Int16,
			["System.UInt16"] = AssetValueType.UInt16,
			["System.Int32"] = AssetValueType.Int32,
			["System.UInt32"] = AssetValueType.UInt32,
			["System.Int64"] = AssetValueType.Int64,
			["System.UInt64"] = AssetValueType.UInt64,
			["System.Double"] = AssetValueType.Double,
			["System.Single"] = AssetValueType.Float,
			["System.String"] = AssetValueType.String
		};

		public static string ConvertBaseToPrimitive(string name)
		{
			if (baseToPrimitive.TryGetValue(name, out var value))
			{
				return value;
			}
			return name;
		}

		public static AssetValueType ConvertBaseToAssetValueType(string name)
		{
			if (baseToAssetValueType.TryGetValue(name, out var value))
			{
				return value;
			}
			return AssetValueType.None;
		}

		public static bool IsSpecialUnityType(string fullName)
		{
			return specialUnityTypes.Contains(fullName);
		}

		public static bool IsAssemblyBlacklisted(string assembly, UnityVersion unityVersion)
		{
			return blacklistedAssemblies.Contains(assembly);
		}

		public static bool IsPrimitiveType(string fullName)
		{
			return primitiveTypes.Contains(fullName);
		}

		public static bool TypeAligns(AssetValueType valueType)
		{
			if (valueType.Equals(AssetValueType.Bool) || valueType.Equals(AssetValueType.Int8) || valueType.Equals(AssetValueType.UInt8) || valueType.Equals(AssetValueType.Int16) || valueType.Equals(AssetValueType.UInt16))
			{
				return true;
			}
			return false;
		}

		public static int GetSerializationLimit(UnityVersion unityVersion)
		{
			if (unityVersion.major > 2020 || (unityVersion.major == 2020 && (unityVersion.minor >= 2 || (unityVersion.minor == 1 && unityVersion.patch >= 4))) || (unityVersion.major == 2019 && unityVersion.minor == 4 && unityVersion.patch >= 9))
			{
				return 10;
			}
			return 7;
		}

		public static AssetTypeTemplateField Bool(string name, bool align = false)
		{
			return CreateTemplateField(name, "bool", AssetValueType.Bool, isArray: false, align);
		}

		public static AssetTypeTemplateField SByte(string name, bool align = false)
		{
			return CreateTemplateField(name, "SInt8", AssetValueType.Int8, isArray: false, align);
		}

		public static AssetTypeTemplateField Byte(string name, bool align = false)
		{
			return CreateTemplateField(name, "UInt8", AssetValueType.UInt8, isArray: false, align);
		}

		public static AssetTypeTemplateField CChar(string name, bool align = false)
		{
			return CreateTemplateField(name, "char", AssetValueType.UInt8, isArray: false, align);
		}

		public static AssetTypeTemplateField Char(string name, bool align = false)
		{
			return CreateTemplateField(name, "UInt16", AssetValueType.UInt16, isArray: false, align);
		}

		public static AssetTypeTemplateField Short(string name, bool align = false)
		{
			return CreateTemplateField(name, "SInt16", AssetValueType.Int16, isArray: false, align);
		}

		public static AssetTypeTemplateField UShort(string name, bool align = false)
		{
			return CreateTemplateField(name, "UInt16", AssetValueType.UInt16, isArray: false, align);
		}

		public static AssetTypeTemplateField Int(string name)
		{
			return CreateTemplateField(name, "int", AssetValueType.Int32);
		}

		public static AssetTypeTemplateField UInt(string name)
		{
			return CreateTemplateField(name, "unsigned int", AssetValueType.UInt32);
		}

		public static AssetTypeTemplateField Long(string name)
		{
			return CreateTemplateField(name, "SInt64", AssetValueType.Int64);
		}

		public static AssetTypeTemplateField ULong(string name)
		{
			return CreateTemplateField(name, "UInt64", AssetValueType.UInt64);
		}

		public static AssetTypeTemplateField Float(string name)
		{
			return CreateTemplateField(name, "float", AssetValueType.Float);
		}

		public static AssetTypeTemplateField Double(string name)
		{
			return CreateTemplateField(name, "double", AssetValueType.Double);
		}

		public static AssetTypeTemplateField String(string name)
		{
			return CreateTemplateField(name, "string", AssetValueType.String, String());
		}

		public static List<AssetTypeTemplateField> String()
		{
			return Array(CChar("data"));
		}

		public static AssetTypeTemplateField Vector(AssetTypeTemplateField field)
		{
			return CreateTemplateField(field.Name, "vector", Array(field));
		}

		public static AssetTypeTemplateField VectorWithType(AssetTypeTemplateField field)
		{
			return CreateTemplateField(field.Name, field.Type, Array(field));
		}

		public static List<AssetTypeTemplateField> Array(AssetTypeTemplateField field)
		{
			AssetTypeTemplateField item = new AssetTypeTemplateField
			{
				Name = "Array",
				Type = "Array",
				ValueType = ((field.ValueType == AssetValueType.UInt8) ? AssetValueType.ByteArray : AssetValueType.Array),
				IsArray = true,
				IsAligned = true,
				HasValue = true,
				Children = new List<AssetTypeTemplateField>
				{
					Int("size"),
					CreateTemplateField("data", field.Type, field.ValueType, field.Children)
				}
			};
			return new List<AssetTypeTemplateField> { item };
		}

		public static AssetTypeTemplateField ManagedReference(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "managedReference", ManagedReference(unityVersion));
		}

		public static List<AssetTypeTemplateField> ManagedReference(UnityVersion unityVersion)
		{
			if (unityVersion.major > 2021 || (unityVersion.major == 2021 && unityVersion.minor >= 2))
			{
				return new List<AssetTypeTemplateField> { Long("rid") };
			}
			return new List<AssetTypeTemplateField> { Int("id") };
		}

		public static AssetTypeTemplateField ManagedReferencesRegistry(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "ManagedReferencesRegistry", AssetValueType.ManagedReferencesRegistry, ManagedReferencesRegistry(unityVersion));
		}

		public static List<AssetTypeTemplateField> ManagedReferencesRegistry(UnityVersion unityVersion)
		{
			if (unityVersion.major > 2021 || (unityVersion.major == 2021 && unityVersion.minor >= 2))
			{
				return new List<AssetTypeTemplateField>
				{
					Int("version"),
					Vector(ReferencedObject("RefIds", unityVersion))
				};
			}
			return new List<AssetTypeTemplateField>
			{
				Int("version"),
				ReferencedObject("00000000", unityVersion)
			};
		}

		public static AssetTypeTemplateField ReferencedObject(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "ReferencedObject", ReferencedObject(unityVersion));
		}

		public static List<AssetTypeTemplateField> ReferencedObject(UnityVersion unityVersion)
		{
			if (unityVersion.major > 2021 || (unityVersion.major == 2021 && unityVersion.minor >= 2))
			{
				return new List<AssetTypeTemplateField>
				{
					Long("rid"),
					ReferencedManagedType("type"),
					CreateTemplateField("data", "ReferencedObjectData", AssetValueType.None)
				};
			}
			return new List<AssetTypeTemplateField>
			{
				ReferencedManagedType("type"),
				CreateTemplateField("data", "ReferencedObjectData", AssetValueType.None)
			};
		}

		public static AssetTypeTemplateField ReferencedManagedType(string name)
		{
			return CreateTemplateField(name, "ReferencedManagedType", ReferencedManagedType());
		}

		public static List<AssetTypeTemplateField> ReferencedManagedType()
		{
			return new List<AssetTypeTemplateField>
			{
				String("class"),
				String("ns"),
				String("asm")
			};
		}

		public static AssetTypeTemplateField Gradient(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "Gradient", Gradient(unityVersion));
		}

		public static List<AssetTypeTemplateField> Gradient(UnityVersion unityVersion)
		{
			if (unityVersion.major > 2022 || (unityVersion.major == 2022 && unityVersion.minor >= 2))
			{
				return new List<AssetTypeTemplateField>
				{
					RGBAf("key0"),
					RGBAf("key1"),
					RGBAf("key2"),
					RGBAf("key3"),
					RGBAf("key4"),
					RGBAf("key5"),
					RGBAf("key6"),
					RGBAf("key7"),
					UShort("ctime0"),
					UShort("ctime1"),
					UShort("ctime2"),
					UShort("ctime3"),
					UShort("ctime4"),
					UShort("ctime5"),
					UShort("ctime6"),
					UShort("ctime7"),
					UShort("atime0"),
					UShort("atime1"),
					UShort("atime2"),
					UShort("atime3"),
					UShort("atime4"),
					UShort("atime5"),
					UShort("atime6"),
					UShort("atime7"),
					Byte("m_Mode"),
					SByte("m_ColorSpace"),
					Byte("m_NumColorKeys"),
					Byte("m_NumAlphaKeys", align: true)
				};
			}
			return new List<AssetTypeTemplateField>
			{
				RGBAf("key0"),
				RGBAf("key1"),
				RGBAf("key2"),
				RGBAf("key3"),
				RGBAf("key4"),
				RGBAf("key5"),
				RGBAf("key6"),
				RGBAf("key7"),
				UShort("ctime0"),
				UShort("ctime1"),
				UShort("ctime2"),
				UShort("ctime3"),
				UShort("ctime4"),
				UShort("ctime5"),
				UShort("ctime6"),
				UShort("ctime7"),
				UShort("atime0"),
				UShort("atime1"),
				UShort("atime2"),
				UShort("atime3"),
				UShort("atime4"),
				UShort("atime5"),
				UShort("atime6"),
				UShort("atime7"),
				Int("m_Mode"),
				Byte("m_NumColorKeys"),
				Byte("m_NumAlphaKeys", align: true)
			};
		}

		public static AssetTypeTemplateField AnimationCurve(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "AnimationCurve", AnimationCurve(unityVersion));
		}

		public static List<AssetTypeTemplateField> AnimationCurve(UnityVersion unityVersion)
		{
			return new List<AssetTypeTemplateField>
			{
				Vector(Keyframe("m_Curve", unityVersion)),
				Int("m_PreInfinity"),
				Int("m_PostInfinity"),
				Int("m_RotationOrder")
			};
		}

		public static AssetTypeTemplateField GUIStyle(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "GUIStyle", GUIStyle(unityVersion));
		}

		public static List<AssetTypeTemplateField> GUIStyle(UnityVersion unityVersion)
		{
			return new List<AssetTypeTemplateField>
			{
				String("m_Name"),
				GUIStyleState("m_Normal", unityVersion),
				GUIStyleState("m_Hover", unityVersion),
				GUIStyleState("m_Active", unityVersion),
				GUIStyleState("m_Focused", unityVersion),
				GUIStyleState("m_OnNormal", unityVersion),
				GUIStyleState("m_OnHover", unityVersion),
				GUIStyleState("m_OnActive", unityVersion),
				GUIStyleState("m_OnFocused", unityVersion),
				RectOffset("m_Border"),
				RectOffset("m_Margin"),
				RectOffset("m_Padding"),
				RectOffset("m_Overflow"),
				PPtr("m_Font", "Font", unityVersion),
				Int("m_FontSize"),
				Int("m_FontStyle"),
				Int("m_Alignment"),
				Bool("m_WordWrap"),
				Bool("m_RichText", align: true),
				Int("m_TextClipping"),
				Int("m_ImagePosition"),
				Vector2f("m_ContentOffset"),
				Float("m_FixedWidth"),
				Float("m_FixedHeight"),
				Bool("m_StretchWidth"),
				Bool("m_StretchHeight", align: true)
			};
		}

		public static AssetTypeTemplateField Keyframe(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "Keyframe", Keyframe(unityVersion));
		}

		public static List<AssetTypeTemplateField> Keyframe(UnityVersion unityVersion)
		{
			if (unityVersion.major >= 2018)
			{
				return new List<AssetTypeTemplateField>
				{
					Float("time"),
					Float("value"),
					Float("inSlope"),
					Float("outSlope"),
					Int("weightedMode"),
					Float("inWeight"),
					Float("outWeight")
				};
			}
			return new List<AssetTypeTemplateField>
			{
				Float("time"),
				Float("value"),
				Float("inSlope"),
				Float("outSlope")
			};
		}

		public static AssetTypeTemplateField GUIStyleState(string name, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "GUIStyleState", GUIStyleState(unityVersion));
		}

		public static List<AssetTypeTemplateField> GUIStyleState(UnityVersion unityVersion)
		{
			return new List<AssetTypeTemplateField>
			{
				PPtr("m_Background", "Texture2D", unityVersion),
				RGBAf("m_TextColor")
			};
		}

		public static AssetTypeTemplateField RGBAf(string name)
		{
			return CreateTemplateField(name, "ColorRGBA", RGBAf());
		}

		public static List<AssetTypeTemplateField> RGBAf()
		{
			return new List<AssetTypeTemplateField>
			{
				Float("r"),
				Float("g"),
				Float("b"),
				Float("a")
			};
		}

		public static AssetTypeTemplateField RGBAi(string name)
		{
			return CreateTemplateField(name, "ColorRGBA", RGBAi());
		}

		public static List<AssetTypeTemplateField> RGBAi()
		{
			return new List<AssetTypeTemplateField> { UInt("rgba") };
		}

		public static AssetTypeTemplateField AABB(string name)
		{
			return CreateTemplateField(name, "AABB", AABB());
		}

		public static List<AssetTypeTemplateField> AABB()
		{
			return new List<AssetTypeTemplateField>
			{
				Vector3f("m_Center"),
				Vector3f("m_Extent")
			};
		}

		public static AssetTypeTemplateField BoundsInt(string name)
		{
			return CreateTemplateField(name, "BoundsInt", BoundsInt());
		}

		public static List<AssetTypeTemplateField> BoundsInt()
		{
			return new List<AssetTypeTemplateField>
			{
				Vector3Int("m_Position"),
				Vector3Int("m_Size")
			};
		}

		public static AssetTypeTemplateField BitField(string name)
		{
			return CreateTemplateField(name, "BitField", BitField());
		}

		public static List<AssetTypeTemplateField> BitField()
		{
			return new List<AssetTypeTemplateField> { UInt("m_Bits") };
		}

		public static AssetTypeTemplateField Rectf(string name)
		{
			return CreateTemplateField(name, "Rectf", Rectf());
		}

		public static List<AssetTypeTemplateField> Rectf()
		{
			return new List<AssetTypeTemplateField>
			{
				Float("x"),
				Float("y"),
				Float("width"),
				Float("height")
			};
		}

		public static AssetTypeTemplateField RectOffset(string name)
		{
			return CreateTemplateField(name, "RectOffset", RectOffset());
		}

		public static List<AssetTypeTemplateField> RectOffset()
		{
			return new List<AssetTypeTemplateField>
			{
				Int("m_Left"),
				Int("m_Right"),
				Int("m_Top"),
				Int("m_Bottom")
			};
		}

		public static AssetTypeTemplateField Vector2Int(string name)
		{
			return CreateTemplateField(name, "int2_storage", Vector2Int());
		}

		public static List<AssetTypeTemplateField> Vector2Int()
		{
			return new List<AssetTypeTemplateField>
			{
				Int("x"),
				Int("y")
			};
		}

		public static AssetTypeTemplateField Vector3Int(string name)
		{
			return CreateTemplateField(name, "int3_storage", Vector3Int());
		}

		public static List<AssetTypeTemplateField> Vector3Int()
		{
			return new List<AssetTypeTemplateField>
			{
				Int("x"),
				Int("y"),
				Int("z")
			};
		}

		public static AssetTypeTemplateField Vector2f(string name)
		{
			return CreateTemplateField(name, "Vector2f", Vector2f());
		}

		public static List<AssetTypeTemplateField> Vector2f()
		{
			return new List<AssetTypeTemplateField>
			{
				Float("x"),
				Float("y")
			};
		}

		public static AssetTypeTemplateField Vector3f(string name)
		{
			return CreateTemplateField(name, "Vector3f", Vector3f());
		}

		public static List<AssetTypeTemplateField> Vector3f()
		{
			return new List<AssetTypeTemplateField>
			{
				Float("x"),
				Float("y"),
				Float("z")
			};
		}

		public static AssetTypeTemplateField PPtr(string name, string typeName, UnityVersion unityVersion)
		{
			return CreateTemplateField(name, "PPtr<" + typeName + ">", PPtr(unityVersion));
		}

		public static List<AssetTypeTemplateField> PPtr(UnityVersion unityVersion)
		{
			if (unityVersion.major >= 5)
			{
				return new List<AssetTypeTemplateField>
				{
					Int("m_FileID"),
					Long("m_PathID")
				};
			}
			return new List<AssetTypeTemplateField>
			{
				Int("m_FileID"),
				Int("m_PathID")
			};
		}

		public static AssetTypeTemplateField PropertyName(string name)
		{
			return CreateTemplateField(name, "string", PropertyName());
		}

		public static List<AssetTypeTemplateField> PropertyName()
		{
			return new List<AssetTypeTemplateField> { String("id") };
		}

		public static AssetTypeTemplateField CreateTemplateField(string name, string type, List<AssetTypeTemplateField> children)
		{
			return CreateTemplateField(name, type, AssetValueType.None, isArray: false, align: false, children);
		}

		public static AssetTypeTemplateField CreateTemplateField(string name, string type, AssetValueType valueType)
		{
			return CreateTemplateField(name, type, valueType, isArray: false, align: false, new List<AssetTypeTemplateField>(0));
		}

		public static AssetTypeTemplateField CreateTemplateField(string name, string type, AssetValueType valueType, bool isArray, bool align)
		{
			return CreateTemplateField(name, type, valueType, isArray, align, new List<AssetTypeTemplateField>(0));
		}

		public static AssetTypeTemplateField CreateTemplateField(string name, string type, AssetValueType valueType, List<AssetTypeTemplateField> children)
		{
			return CreateTemplateField(name, type, valueType, isArray: false, align: false, children);
		}

		public static AssetTypeTemplateField CreateTemplateField(string name, string type, AssetValueType valueType, bool isArray, bool align, List<AssetTypeTemplateField> children)
		{
			return new AssetTypeTemplateField
			{
				Name = name,
				Type = type,
				ValueType = valueType,
				IsArray = isArray,
				IsAligned = align,
				HasValue = (valueType != AssetValueType.None),
				Children = (children ?? new List<AssetTypeTemplateField>(0))
			};
		}
	}
	public static class Net35Polyfill
	{
		public static void CopyToCompat(this Stream input, Stream output, long bytes = -1L, int bufferSize = 81920)
		{
			byte[] array = new byte[bufferSize];
			if (bytes == -1)
			{
				bytes = long.MaxValue;
			}
			int num;
			while (bytes > 0 && (num = input.Read(array, 0, (int)Math.Min(array.Length, bytes))) > 0)
			{
				output.Write(array, 0, num);
				bytes -= num;
			}
		}

		public static bool HasFlag(Enum variable, Enum value)
		{
			if (variable == null)
			{
				return false;
			}
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (!Enum.IsDefined(variable.GetType(), value))
			{
				throw new ArgumentException($"Enumeration type mismatch.  The flag is of type '{value.GetType()}', was expecting '{variable.GetType()}'.");
			}
			ulong num = Convert.ToUInt64(value);
			return (Convert.ToUInt64(variable) & num) == num;
		}
	}
	public class UnityVersion
	{
		public int major;

		public int minor;

		public int patch;

		public string type;

		public int typeNum;

		public UnityVersion()
		{
		}

		public UnityVersion(string version)
		{
			string[] array = version.Split('.');
			major = int.Parse(array[0]);
			minor = int.Parse(array[1]);
			int num = array[2].IndexOfAny(new char[6] { 'f', 'p', 'a', 'b', 'c', 'x' });
			if (num != -1)
			{
				type = array[2][num].ToString();
				patch = int.Parse(array[2].Substring(0, num));
				string text = array[2].Substring(num + 1);
				if (!int.TryParse(text, out typeNum))
				{
					string text2 = "";
					for (int i = 0; i < text.Length && text[i] >= '0' && text[i] <= '9'; i++)
					{
						text2 += text[i];
					}
					if (text2.Length > 0)
					{
						typeNum = int.Parse(text2);
					}
				}
			}
			else
			{
				patch = int.Parse(array[2]);
				type = "";
				typeNum = 0;
			}
		}

		public override string ToString()
		{
			if (type == string.Empty)
			{
				return $"{major}.{minor}.{patch}";
			}
			return $"{major}.{minor}.{patch}{type}{typeNum}";
		}

		public ulong ToUInt64()
		{
			string text = type;
			if (1 == 0)
			{
			}
			byte b = text switch
			{
				"a" => 0, 
				"b" => 1, 
				"c" => 2, 
				"f" => 3, 
				"p" => 4, 
				"x" => 5, 
				_ => byte.MaxValue, 
			};
			if (1 == 0)
			{
			}
			byte b2 = b;
			return (ulong)(((long)major << 48) | ((long)minor << 32) | ((long)patch << 16)) | ((ulong)b2 << 8) | (uint)typeNum;
		}

		public static UnityVersion FromUInt64(ulong data)
		{
			UnityVersion unityVersion = new UnityVersion();
			unityVersion.major = (int)((data >> 48) & 0xFFFF);
			unityVersion.minor = (int)((data >> 32) & 0xFFFF);
			unityVersion.patch = (int)((data >> 16) & 0xFFFF);
			UnityVersion unityVersion2 = unityVersion;
			ulong num = (data >> 8) & 0xFF;
			if (1 == 0)
			{
			}
			if (num > 5)
			{
				goto IL_00ac;
			}
			switch (num)
			{
			case 0uL:
				break;
			case 1uL:
				goto IL_0084;
			case 2uL:
				goto IL_008c;
			case 3uL:
				goto IL_0094;
			case 4uL:
				goto IL_009c;
			case 5uL:
				goto IL_00a4;
			default:
				goto IL_00ac;
			}
			string text = "a";
			goto IL_00b4;
			IL_0084:
			text = "b";
			goto IL_00b4;
			IL_00b4:
			if (1 == 0)
			{
			}
			unityVersion2.type = text;
			unityVersion.typeNum = (int)(data & 0xFF);
			return unityVersion;
			IL_00ac:
			text = "?";
			goto IL_00b4;
			IL_00a4:
			text = "x";
			goto IL_00b4;
			IL_009c:
			text = "p";
			goto IL_00b4;
			IL_0094:
			text = "f";
			goto IL_00b4;
			IL_008c:
			text = "c";
			goto IL_00b4;
		}
	}
	public class ValueBuilder
	{
		public static AssetTypeValueField DefaultValueFieldFromArrayTemplate(AssetTypeValueField arrayField)
		{
			return DefaultValueFieldFromArrayTemplate(arrayField.TemplateField);
		}

		public static AssetTypeValueField DefaultValueFieldFromArrayTemplate(AssetTypeTemplateField arrayField)
		{
			if (!arrayField.IsArray)
			{
				return null;
			}
			AssetTypeTemplateField templateField = arrayField.Children[1];
			return DefaultValueFieldFromTemplate(templateField);
		}

		public static AssetTypeValueField DefaultValueFieldFromTemplate(AssetTypeTemplateField templateField)
		{
			List<AssetTypeTemplateField> children = templateField.Children;
			List<AssetTypeValueField> list;
			if (templateField.IsArray || templateField.ValueType == AssetValueType.String)
			{
				list = new List<AssetTypeValueField>(0);
			}
			else
			{
				list = new List<AssetTypeValueField>(children.Count);
				for (int i = 0; i < children.Count; i++)
				{
					list.Add(DefaultValueFieldFromTemplate(children[i]));
				}
			}
			AssetTypeValue value = DefaultValueFromTemplate(templateField);
			return new AssetTypeValueField
			{
				Children = list,
				TemplateField = templateField,
				Value = value
			};
		}

		public static AssetTypeValue DefaultValueFromTemplate(AssetTypeTemplateField templateField)
		{
			object obj;
			switch (templateField.ValueType)
			{
			case AssetValueType.Int8:
				obj = (sbyte)0;
				break;
			case AssetValueType.UInt8:
				obj = (byte)0;
				break;
			case AssetValueType.Bool:
				obj = false;
				break;
			case AssetValueType.Int16:
				obj = (short)0;
				break;
			case AssetValueType.UInt16:
				obj = (ushort)0;
				break;
			case AssetValueType.Int32:
				obj = 0;
				break;
			case AssetValueType.UInt32:
				obj = 0u;
				break;
			case AssetValueType.Int64:
				obj = 0L;
				break;
			case AssetValueType.UInt64:
				obj = 0uL;
				break;
			case AssetValueType.Float:
				obj = 0f;
				break;
			case AssetValueType.Double:
				obj = 0.0;
				break;
			case AssetValueType.String:
			case AssetValueType.ByteArray:
				obj = new byte[0];
				break;
			case AssetValueType.Array:
				obj = default(AssetTypeArrayInfo);
				break;
			case AssetValueType.ManagedReferencesRegistry:
				obj = new ManagedReferencesRegistry();
				break;
			default:
				obj = null;
				break;
			}
			if (obj == null && templateField.IsArray)
			{
				obj = default(AssetTypeArrayInfo);
				return new AssetTypeValue(AssetValueType.Array, obj);
			}
			return new AssetTypeValue(templateField.ValueType, obj);
		}
	}
}
namespace AssetsTools.NET.Extra.Decompressors.LZ4
{
	public class Lz4DecoderStream : Stream
	{
		private enum DecodePhase
		{
			ReadToken,
			ReadExLiteralLength,
			CopyLiteral,
			ReadOffset,
			ReadExMatchLength,
			CopyMatch
		}

		private long inputLength;

		private Stream input;

		private const int DecBufLen = 65536;

		private const int DecBufMask = 65535;

		private const int InBufLen = 128;

		private byte[] decodeBuffer = new byte[65664];

		private int decodeBufferPos;

		private int inBufPos;

		private int inBufEnd;

		private DecodePhase phase;

		private int litLen;

		private int matLen;

		private int matDst;

		public override bool CanRead => true;

		public override bool CanSeek => false;

		public override bool CanWrite => false;

		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override long Position
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public Lz4DecoderStream(Stream input, long inputLength = long.MaxValue)
		{
			Reset(input, inputLength);
		}

		public void Reset(Stream input, long inputLength = long.MaxValue)
		{
			this.inputLength = inputLength;
			this.input = input;
			phase = DecodePhase.ReadToken;
			decodeBufferPos = 0;
			litLen = 0;
			matLen = 0;
			matDst = 0;
			inBufPos = 65536;
			inBufEnd = 65536;
		}

		public override void Close()
		{
			input = null;
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0 || count < 0 || buffer.Length - count < offset)
			{
				throw new ArgumentOutOfRangeException();
			}
			if (input == null)
			{
				throw new InvalidOperationException();
			}
			int num = count;
			byte[] array = decodeBuffer;
			int num8;
			switch (phase)
			{
			default:
			{
				int num2;
				if (inBufPos < inBufEnd)
				{
					num2 = array[inBufPos++];
				}
				else
				{
					num2 = ReadByteCore();
					if (num2 == -1)
					{
						break;
					}
				}
				litLen = num2 >> 4;
				matLen = (num2 & 0xF) + 4;
				int num3 = litLen;
				int num4 = num3;
				if (num4 != 0)
				{
					if (num4 == 15)
					{
						phase = DecodePhase.ReadExLiteralLength;
						goto case DecodePhase.ReadExLiteralLength;
					}
					phase = DecodePhase.CopyLiteral;
					goto case DecodePhase.CopyLiteral;
				}
				phase = DecodePhase.ReadOffset;
				goto case DecodePhase.ReadOffset;
			}
			case DecodePhase.ReadExLiteralLength:
				while (true)
				{
					int num16;
					if (inBufPos < inBufEnd)
					{
						num16 = array[inBufPos++];
					}
					else
					{
						num16 = ReadByteCore();
						if (num16 == -1)
						{
							break;
						}
					}
					litLen += num16;
					if (num16 == 255)
					{
						continue;
					}
					goto IL_019b;
				}
				break;
			case DecodePhase.CopyLiteral:
				do
				{
					int num5 = ((litLen < num) ? litLen : num);
					if (num5 == 0)
					{
						break;
					}
					if (inBufPos + num5 <= inBufEnd)
					{
						int num6 = offset;
						int num7 = num5;
						while (num7-- != 0)
						{
							buffer[num6++] = array[inBufPos++];
						}
						num8 = num5;
					}
					else
					{
						num8 = ReadCore(buffer, offset, num5);
						if (num8 == 0)
						{
							goto end_IL_0061;
						}
					}
					offset += num8;
					num -= num8;
					litLen -= num8;
				}
				while (litLen != 0);
				if (num == 0)
				{
					break;
				}
				phase = DecodePhase.ReadOffset;
				goto case DecodePhase.ReadOffset;
			case DecodePhase.ReadOffset:
				if (inBufPos + 1 < inBufEnd)
				{
					matDst = (array[inBufPos + 1] << 8) | array[inBufPos];
					inBufPos += 2;
				}
				else
				{
					matDst = ReadOffsetCore();
					if (matDst == -1)
					{
						break;
					}
				}
				if (matLen == 19)
				{
					phase = DecodePhase.ReadExMatchLength;
					goto case DecodePhase.ReadExMatchLength;
				}
				phase = DecodePhase.CopyMatch;
				goto case DecodePhase.CopyMatch;
			case DecodePhase.ReadExMatchLength:
				while (true)
				{
					int num15;
					if (inBufPos < inBufEnd)
					{
						num15 = array[inBufPos++];
					}
					else
					{
						num15 = ReadByteCore();
						if (num15 == -1)
						{
							break;
						}
					}
					matLen += num15;
					if (num15 == 255)
					{
						continue;
					}
					goto IL_0376;
				}
				break;
			case DecodePhase.CopyMatch:
				{
					int num9 = ((matLen < num) ? matLen : num);
					if (num9 != 0)
					{
						num8 = count - num;
						int num10 = matDst - num8;
						if (num10 > 0)
						{
							int num11 = decodeBufferPos - num10;
							if (num11 < 0)
							{
								num11 += 65536;
							}
							int num12 = ((num10 < num9) ? num10 : num9);
							int num13 = num12;
							while (num13-- != 0)
							{
								buffer[offset++] = array[num11++ & 0xFFFF];
							}
						}
						else
						{
							num10 = 0;
						}
						int num14 = offset - matDst;
						for (int i = num10; i < num9; i++)
						{
							buffer[offset++] = buffer[num14++];
						}
						num -= num9;
						matLen -= num9;
					}
					if (num == 0)
					{
						break;
					}
					phase = DecodePhase.ReadToken;
					goto default;
				}
				IL_0376:
				phase = DecodePhase.CopyMatch;
				goto case DecodePhase.CopyMatch;
				IL_019b:
				phase = DecodePhase.CopyLiteral;
				goto case DecodePhase.CopyLiteral;
				end_IL_0061:
				break;
			}
			num8 = count - num;
			int num17 = ((num8 < 65536) ? num8 : 65536);
			int srcOffset = offset - num17;
			if (num17 == 65536)
			{
				Buffer.BlockCopy(buffer, srcOffset, array, 0, 65536);
				decodeBufferPos = 0;
			}
			else
			{
				int num18 = decodeBufferPos;
				while (num17-- != 0)
				{
					array[num18++ & 0xFFFF] = buffer[srcOffset++];
				}
				decodeBufferPos = num18 & 0xFFFF;
			}
			return num8;
		}

		private int ReadByteCore()
		{
			byte[] array = decodeBuffer;
			if (inBufPos == inBufEnd)
			{
				int num = input.Read(array, 65536, (int)((128 < inputLength) ? 128 : inputLength));
				if (num == 0)
				{
					return -1;
				}
				inputLength -= num;
				inBufPos = 65536;
				inBufEnd = 65536 + num;
			}
			return array[inBufPos++];
		}

		private int ReadOffsetCore()
		{
			byte[] array = decodeBuffer;
			if (inBufPos == inBufEnd)
			{
				int num = input.Read(array, 65536, (int)((128 < inputLength) ? 128 : inputLength));
				if (num == 0)
				{
					return -1;
				}
				inputLength -= num;
				inBufPos = 65536;
				inBufEnd = 65536 + num;
			}
			if (inBufEnd - inBufPos == 1)
			{
				array[65536] = array[inBufPos];
				int num2 = input.Read(array, 65537, (int)((127 < inputLength) ? 127 : inputLength));
				if (num2 == 0)
				{
					inBufPos = 65536;
					inBufEnd = 65537;
					return -1;
				}
				inputLength -= num2;
				inBufPos = 65536;
				inBufEnd = 65536 + num2 + 1;
			}
			int result = (array[inBufPos + 1] << 8) | array[inBufPos];
			inBufPos += 2;
			return result;
		}

		private int ReadCore(byte[] buffer, int offset, int count)
		{
			int num = count;
			byte[] array = decodeBuffer;
			int num2 = inBufEnd - inBufPos;
			int num3 = ((num < num2) ? num : num2);
			if (num3 != 0)
			{
				int num4 = inBufPos;
				int num5 = num3;
				while (num5-- != 0)
				{
					buffer[offset++] = array[num4++];
				}
				inBufPos = num4;
				num -= num3;
			}
			if (num != 0)
			{
				int num6;
				if (num >= 128)
				{
					num6 = input.Read(buffer, offset, (int)((num < inputLength) ? num : inputLength));
					num -= num6;
				}
				else
				{
					num6 = input.Read(array, 65536, (int)((128 < inputLength) ? 128 : inputLength));
					inBufPos = 65536;
					inBufEnd = 65536 + num6;
					num3 = ((num < num6) ? num : num6);
					int num7 = inBufPos;
					int num8 = num3;
					while (num8-- != 0)
					{
						buffer[offset++] = array[num7++];
					}
					inBufPos = num7;
					num -= num3;
				}
				inputLength -= num6;
			}
			return count - num;
		}

		public override void Flush()
		{
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException();
		}

		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			throw new NotSupportedException();
		}
	}
}
namespace AdvancedCompany
{
	public class AnimationClipOverrides : List<KeyValuePair<AnimationClip, AnimationClip>>
	{
		public AnimationClip this[string name]
		{
			get
			{
				return Find((KeyValuePair<AnimationClip, AnimationClip> x) => ((Object)x.Key).name.Equals(name)).Value;
			}
			set
			{
				int num = FindIndex((KeyValuePair<AnimationClip, AnimationClip> x) => ((Object)x.Key).name.Equals(name));
				if (num != -1)
				{
					base[num] = new KeyValuePair<AnimationClip, AnimationClip>(base[num].Key, value);
				}
			}
		}

		public AnimationClipOverrides(int capacity)
			: base(capacity)
		{
		}
	}
	[Bootable]
	public class Assets
	{
		public static AssetBundle AssetBundle;

		public static void Boot()
		{
			string text = Path.Combine(Path.GetDirectoryName(typeof(Assets).Assembly.Location), "advancedcompany/advancedcompanyassets");
			if (!File.Exists(text))
			{
				text = Path.Combine(Path.GetDirectoryName(typeof(Assets).Assembly.Location), "advancedcompanyassets");
			}
			AssetBundle = AssetBundle.LoadFromFile(text);
			BootManager.AddTypeCallback(delegate(Type type)
			{
				if (type.GetCustomAttribute<LoadAssets>() != null)
				{
					MethodInfo method = type.GetMethod("LoadAssets", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
					if (method != null)
					{
						ParameterInfo[] parameters = method.GetParameters();
						if (parameters.Length == 1 && parameters[0].ParameterType == typeof(AssetBundle))
						{
							method.Invoke(null, new object[1] { AssetBundle });
						}
						else
						{
							Plugin.Log.LogError((object)("Method " + method.DeclaringType.FullName + "->" + method.Name + " has wrong parameters."));
						}
					}
					else
					{
						Plugin.Log.LogError((object)("Type " + type.FullName + " is missing static LoadAssets method."));
					}
				}
			});
		}
	}
	public static class CodeInstructionExtensions
	{
		public static bool IsLdfld(this CodeInstruction instruction, string fieldName = null)
		{
			if (instruction.opcode == OpCodes.Ldfld)
			{
				if (fieldName != null && instruction.operand is FieldInfo fieldInfo)
				{
					string text = fieldInfo.DeclaringType.FullName + "." + fieldInfo.Name;
					return text == fieldName;
				}
				return true;
			}
			return false;
		}
	}
	public static class GameAssets
	{
		public static Dictionary<string, Item> Scrap = new Dictionary<string, Item>();

		public static Dictionary<string, AudioClip> Audio = new Dictionary<string, AudioClip>();
	}
	[Bootable]
	public class HDRPChanges
	{
		public static void Boot()
		{
			//IL_001e: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogDebug((object)"Patching HDRP...");
			try
			{
				RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
				HDRenderPipelineAsset val = (HDRenderPipelineAsset)(object)((currentRenderPipeline is HDRenderPipelineAsset) ? currentRenderPipeline : null);
				RenderPipelineSettings currentPlatformRenderPipelineSettings = val.currentPlatformRenderPipelineSettings;
				Type type = typeof(HDRenderPipelineAsset).Assembly.GetType("UnityEngine.Rendering.HighDefinition.HDRenderPipelineGlobalSettings");
				PropertyInfo property = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
				object value = property.GetValue(null);
				FieldInfo field = type.GetField("afterPostProcessCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				List<string> list = (List<string>)field.GetValue(value);
				list.Add(typeof(AdvancedCompany.PostProcessing.VisionEnhancer).AssemblyQualifiedName);
				currentPlatformRenderPipelineSettings.lightLoopSettings.cookieAtlasSize = (CookieAtlasResolution)2048;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while patching HDRP!");
				Plugin.Log.LogError((object)ex);
			}
		}
	}
	public class LoadAssets : Attribute
	{
	}
	[Requires(typeof(ServerConfiguration))]
	[Bootable]
	internal class Perks : NetworkBehaviour
	{
		internal static Perk SprintSpeedPerk;

		internal static Perk JumpHeightPerk;

		internal static Perk JumpStaminaPerk;

		internal static Perk SprintStaminaPerk;

		internal static Perk StaminaRegenPerk;

		internal static Perk FallDamagePerk;

		internal static Perk DamagePerk;

		internal static Perk WeightPerk;

		internal static Perk WeightSpeedPerk;

		internal static Perk InventorySlotsPerk;

		internal static Perk DealDamagePerk;

		internal static Perk ClimbingSpeedPerk;

		internal static Perk ScanDistancePerk;

		internal static Perk ExtraBatteryPerk;

		internal static Perk ExtendDeadlineDiscountPerk;

		internal static Perk LandingSpeedPerk;

		internal static Perk DeliverySpeedPerk;

		internal static Perk SaveLootPerk;

		internal static Perk TravelDiscountPerk;

		public static int ExtendDeadlinePrice
		{
			get
			{
				if ((Object)(object)TimeOfDay.Instance != (Object)null)
				{
					return (int)((float)TimeOfDay.Instance.profitQuota * GetMultiplier(ExtendDeadlineDiscountPerk));
				}
				return 0;
			}
		}

		public static void Boot()
		{
			SprintSpeedPerk = new Perk(Perk.Type.PLAYER, "SprintSpeed", "Sprint speed", "Increases your sprint speed by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.SprintSpeed, (float baseValue, float change, int level) => baseValue + (float)level * change);
			JumpHeightPerk = new Perk(Perk.Type.PLAYER, "JumpHeight", "Jump height", "Increases your jump height by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.JumpHeight, (float baseValue, float change, int level) => baseValue + (float)level * change);
			JumpStaminaPerk = new Perk(Perk.Type.PLAYER, "JumpStamina", "Jump endurance", "Reduces stamina usage of jumping by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.JumpStamina, (float baseValue, float change, int level) => baseValue - (float)level * change);
			SprintStaminaPerk = new Perk(Perk.Type.PLAYER, "SprintStamina", "Sprint endurance", "Reduces stamina usage of sprinting by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.SprintStamina, (float baseValue, float change, int level) => baseValue + (float)level * change);
			StaminaRegenPerk = new Perk(Perk.Type.PLAYER, "StaminaRegen", "Stamina regen", "Increases stamina regeneration by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.StaminaRegen, (float baseValue, float change, int level) => baseValue + (float)level * change);
			FallDamagePerk = new Perk(Perk.Type.PLAYER, "FallDamage", "Reinforced legs", "Increases the depth you can fall without damage by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.FallDamage, (float baseValue, float change, int level) => baseValue + (float)level * change);
			DamagePerk = new Perk(Perk.Type.PLAYER, "Damage", "Protective skin", "Reduces damage from enemies by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.Damage, (float baseValue, float change, int level) => baseValue - (float)level * change);
			WeightPerk = new Perk(Perk.Type.PLAYER, "Weight", "Bodybuilder", "Reduces stamina loss impact of weight when sprinting by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.Weight, (float baseValue, float change, int level) => baseValue - (float)level * change);
			WeightSpeedPerk = new Perk(Perk.Type.PLAYER, "WeightSpeed", "Heavy runner", "Reduces speed loss impact of weight by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.WeightSpeed, (float baseValue, float change, int level) => baseValue - (float)level * change);
			InventorySlotsPerk = new Perk(Perk.Type.PLAYER, "InventorySlots", "Carry bags", "Increases inventory size by 1 per level.", ServerConfiguration.Instance.PlayerPerks.InventorySlots, (float baseValue, float change, int level) => baseValue + (float)level);
			DealDamagePerk = new Perk(Perk.Type.PLAYER, "DealDamage", "Strong arms", "Increases the chance for a critical strike by [change]%. Critical strikes will kill enemies with one hit.", ServerConfiguration.Instance.PlayerPerks.DealDamage, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ClimbingSpeedPerk = new Perk(Perk.Type.PLAYER, "ClimbingSpeed", "Climbing speed", "Increases climbing speed by [change]% per level.", ServerConfiguration.Instance.PlayerPerks.ClimbingSpeed, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ScanDistancePerk = new Perk(Perk.Type.SHIP, "ScanDistance", "Scanner distance", "Increases the distance of the scanner by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ScanDistance, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ExtraBatteryPerk = new Perk(Perk.Type.SHIP, "ExtraBattery", "Batterypack", "Increases battery capacity of items by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ExtraBattery, (float baseValue, float change, int level) => baseValue + (float)level * change);
			ExtendDeadlineDiscountPerk = new Perk(Perk.Type.SHIP, "ExtendDeadlineDiscount", "Deadline discount", "Decreases the cost to extend the deadline by [change]% per level.", ServerConfiguration.Instance.ShipPerks.ExtendDeadlineDiscount, (float baseValue, float change, int level) => baseValue - (float)level * change);
			LandingSpeedPerk = new Perk(Perk.Type.SHIP, "LandingSpeed", "Landing speed", "Reduces the time to land and lift off by [change]% per level.", ServerConfiguration.Instance.ShipPerks.LandingSpeed, (float baseValue, float change, int level) => baseValue - (float)level * change);
			DeliverySpeedPerk = new Perk(Perk.Type.SHIP, "DeliverySpeed", "Express delivery", "Reduces the time for deliveries to arrive by [change]% per level.", ServerConfiguration.Instance.ShipPerks.DeliverySpeed, (float baseValue, float change, int level) => baseValue - (float)level * change);
			SaveLootPerk = new Perk(Perk.Type.SHIP, "SaveLoot", "Loot saver", "Increases the amount of saved loot by [change]% per level.", ServerConfiguration.Instance.ShipPerks.SaveLoot, (float baseValue, float change, int level) => baseValue + (float)level * change);
			TravelDiscountPerk = new Perk(Perk.Type.SHIP, "TravelDiscount", "Travel discount", "Decreases the price to travel to moons by [change]% per level.", ServerConfiguration.Instance.ShipPerks.TravelDiscount, (float baseValue, float change, int level) => baseValue - (float)level * change);
			AdvancedCompany.Network.Manager.AddListener<ExtendDeadline>(delegate
			{
				ExtendDeadline();
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangePerk message)
			{
				Perk perk = Perk.Perks[message.ID];
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					AdvancedCompany.Game.Player player3 = AdvancedCompany.Network.Manager.Lobby.Player(message.PlayerNum);
					player3.SetLevel(perk, message.Level);
					if (message.PlayerNum == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
					{
						player3.SaveLocal();
					}
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player3.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				else if (perk.PerkType == Perk.Type.SHIP)
				{
					Ship currentShip2 = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					currentShip2.SetLevel(perk, message.Level);
					if (NetworkManager.Singleton.IsServer)
					{
						currentShip2.Save(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(Respec message)
			{
				if (message.Type == Perk.Type.PLAYER)
				{
					AdvancedCompany.Game.Player player2 = AdvancedCompany.Network.Manager.Lobby.Player(message.PlayerNum);
					player2.Reset(message.Reset);
					if (message.PlayerNum == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
					{
						player2.SaveLocal();
					}
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player2.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				else if (message.Type == Perk.Type.SHIP)
				{
					Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					currentShip.Reset(message.Reset);
					if (NetworkManager.Singleton.IsServer)
					{
						currentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(GrantPlayerXP message)
			{
				if (message.All)
				{
					foreach (KeyValuePair<int, AdvancedCompany.Game.Player> connectedPlayer in AdvancedCompany.Network.Manager.Lobby.ConnectedPlayers)
					{
						connectedPlayer.Value.XP += message.XP;
						if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
						{
							connectedPlayer.Value.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
						}
					}
					HUDManager.Instance.DisplayTip("XP gained!", "You have gained " + message.XP + " for fulfilling the quota. Type \"perks\" on the portable terminal to level up.", false, false, "LC_Tip1");
				}
				else
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player(message.PlayerNum);
					player.XP += message.XP;
					if (!ServerConfiguration.Instance.General.SaveProgress && NetworkManager.Singleton.IsServer)
					{
						player.SaveServer(GameNetworkManager.Instance.currentSaveFileName);
					}
				}
				if (message.All || message.PlayerNum == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					AdvancedCompany.Network.Manager.Lobby.Player().SaveLocal();
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(GrantShipXP message)
			{
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.XP += message.XP;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangeShip message)
			{
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota = message.TotalQuota;
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.ExtendedDeadline = message.ExtendedDeadline;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(GameNetworkManager.Instance.currentSaveFileName);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(DeadlineChanged message)
			{
				HUDManager.Instance.DisplayTip("Deadline extended", "Deadline was extended by a day!", false, false, "LC_Tip1");
				TimeOfDay.Instance.timeUntilDeadline = message.NewDeadline;
				TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
			});
		}

		public static void OnClientExtendDeadline(ulong clientId, FastBufferReader reader)
		{
			ExtendDeadline();
		}

		public static void OnDeadlineSync(ulong clientId, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			float timeUntilDeadline = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref timeUntilDeadline, default(ForPrimitives));
			TimeOfDay.Instance.timeUntilDeadline = timeUntilDeadline;
			TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
		}

		public static void ExtendDeadline()
		{
			int extendDeadlinePrice = ExtendDeadlinePrice;
			if (extendDeadlinePrice <= AdvancedCompany.Game.Manager.Terminal.groupCredits)
			{
				TimeOfDay instance = TimeOfDay.Instance;
				instance.timeUntilDeadline += TimeOfDay.Instance.totalTime;
				HUDManager.Instance.DisplayTip("Deadline extended", "Deadline was extended by day!", false, false, "LC_Tip1");
				TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
				Terminal terminal = AdvancedCompany.Game.Manager.Terminal;
				terminal.groupCredits -= extendDeadlinePrice;
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Game.Manager.Terminal.SyncGroupCreditsServerRpc(AdvancedCompany.Game.Manager.Terminal.groupCredits, AdvancedCompany.Game.Manager.Terminal.numberOfItemsInDropship);
					AdvancedCompany.Network.Manager.SendToAll(new DeadlineChanged
					{
						NewDeadline = TimeOfDay.Instance.timeUntilDeadline
					});
					AdvancedCompany.Network.Manager.Send(new ChangeShip
					{
						TotalQuota = AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota,
						ExtendedDeadline = true
					}, 0uL);
				}
				else
				{
					AdvancedCompany.Network.Manager.Send(new ExtendDeadline(), 0uL);
				}
			}
		}

		public static float GetMultiplier(Perk perk)
		{
			if (AdvancedCompany.Network.Manager.Lobby != null)
			{
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player();
					if (player != null)
					{
						if (player.MultiplierOverrides.ContainsKey(perk.ID))
						{
							return player.MultiplierOverrides[perk.ID];
						}
						return perk.GetMultiplier(player);
					}
				}
				else if (perk.PerkType == Perk.Type.SHIP)
				{
					Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
					if (currentShip != null)
					{
						return perk.GetMultiplier(currentShip);
					}
				}
			}
			return 1f;
		}

		public static float GetMultiplier(string perkName)
		{
			if (Perk.Perks.ContainsKey(perkName))
			{
				return GetMultiplier(Perk.Perks[perkName]);
			}
			return 1f;
		}

		public static float GetMultiplier(ulong clientID, string perkName)
		{
			if (Perk.Perks.ContainsKey(perkName) && AdvancedCompany.Network.Manager.Lobby != null)
			{
				Perk perk = Perk.Perks[perkName];
				if (perk.PerkType == Perk.Type.PLAYER)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player();
					if (player != null)
					{
						return Perk.Perks[perkName].GetMultiplier(player);
					}
				}
			}
			return 1f;
		}

		public static float GetMultiplier(PlayerControllerB controller, string perkName)
		{
			if ((Object)(object)controller != (Object)null)
			{
				return GetMultiplier(controller.playerClientId, perkName);
			}
			return 1f;
		}

		public static int InventorySlots()
		{
			AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player();
			if (player != null)
			{
				return (int)Mathf.Clamp(Mathf.Round(ServerConfiguration.Instance.PlayerPerks.InventorySlots.Base + (float)Perk.Perks["InventorySlots"].GetLevel(player)), 0f, 10f);
			}
			return 4;
		}

		public static int InventorySlotsOf(PlayerControllerB controller)
		{
			if (Perk.Perks.ContainsKey("InventorySlots") && AdvancedCompany.Network.Manager.Lobby != null)
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player((int)controller.playerClientId);
				if (player != null)
				{
					return (int)Mathf.Clamp(Mathf.Round(ServerConfiguration.Instance.PlayerPerks.InventorySlots.Base + (float)Perk.Perks["InventorySlots"].GetLevel(player)), 0f, 10f);
				}
			}
			return 10;
		}
	}
	[LoadAssets]
	public class PlayerRocketBoots : MonoBehaviour
	{
		public GameObject LeftRocket;

		public GameObject RightRocket;

		private ParticleSystem LeftParticles;

		private ParticleSystem RightParticles;

		private bool Initialized = false;

		private static GameObject LeftRocketBootPrefab;

		private static GameObject RightRocketBootPrefab;

		public static void LoadAssets(AssetBundle assets)
		{
			LeftRocketBootPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Objects/RocketBootsLeft.prefab");
			RightRocketBootPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Objects/RocketBootsRight.prefab");
		}

		public void Awake()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)this).transform.Find("ScavengerModel").Find("metarig").Find("spine");
			Transform val2 = val.Find("thigh.L").Find("shin.L").Find("foot.L");
			Transform val3 = val.Find("thigh.R").Find("shin.R").Find("foot.R");
			if ((Object)(object)LeftRocket == (Object)null)
			{
				LeftRocket = Object.Instantiate<GameObject>(LeftRocketBootPrefab, val2);
				LeftRocket.transform.localPosition = new Vector3(-0.0786f, -0.0302f, 0.0056f);
				LeftRocket.transform.localEulerAngles = new Vector3(-54.256f, -170.885f, 169.978f);
				LeftRocket.transform.localScale = new Vector3(0.5319018f, 0.5319018f, 0.5319018f);
				LeftParticles = ((Component)LeftRocket.transform.Find("Particles")).GetComponent<ParticleSystem>();
			}
			if ((Object)(object)RightRocket == (Object)null)
			{
				RightRocket = Object.Instantiate<GameObject>(RightRocketBootPrefab, val3);
				RightRocket.transform.localPosition = new Vector3(0.0833f, -0.0401f, 0.0086f);
				RightRocket.transform.localEulerAngles = new Vector3(-124.165f, 0.07899f, -0.55297f);
				RightRocket.transform.localScale = new Vector3(0.5319018f, 0.5319018f, 0.5319018f);
				RightParticles = ((Component)RightRocket.transform.Find("Particles")).GetComponent<ParticleSystem>();
			}
		}

		public void PlayParticles()
		{
			LeftParticles.Play();
			RightParticles.Play();
		}
	}
	[BepInPlugin("com.potatoepet.AdvancedCompany", "AdvancedCompany", "1.1.4")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string Version = "1.1.4";

		private const string GUID = "com.potatoepet.AdvancedCompany";

		internal static ManualLogSource Log;

		internal static Plugin Instance;

		internal static bool UseAnimationOverride = false;

		internal static List<Assembly> AssembliesToScan = new List<Assembly>();

		internal static bool Cripple = false;

		private static List<string> IgnoreAssemblies = new List<string>
		{
			"System", "Facepunch", "Dissonance", "ClientNetworkTransform", "Newtonsoft", "netstandard", "UnityEngine", "eval", "Unity.", "HarmonyDTF",
			"mscorlib", "Mono", "Assembly-CSharp", "UniverseLib", "AmazingAssets", "MMHOOK"
		};

		private void Awake()
		{
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Expected O, but got Unknown
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Log = ((BaseUnityPlugin)this).Logger;
				Mod.RegisterRequiredMod((BaseUnityPlugin)(object)this);
				try
				{
					Log.LogInfo((object)"Manually loading MoreCompany stub...");
					AppDomain.CurrentDomain.Load(File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location), "MoreCompany.dll")));
					Log.LogInfo((object)"MoreCompany Stub loaded!");
				}
				catch (Exception ex)
				{
					Log.LogError((object)"Error while loading MoreCompany.dll stub:");
					Log.LogError((object)ex);
				}
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					if ((Object)(object)pluginInfo.Value.Instance != (Object)null)
					{
						CheckAssembly(((object)pluginInfo.Value.Instance).GetType().Assembly);
					}
				}
				AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				Assembly[] array = assemblies;
				foreach (Assembly assembly in array)
				{
					CheckAssemblyPatches(assembly);
				}
				Instance = this;
				BootManager.Boot();
				Log.LogDebug((object)"Patching with harmony...");
				Harmony.CreateAndPatchAll(typeof(KillPlayer), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Network.Manager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(BulletProofVest), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(LightningRod), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Objects.VisionEnhancer), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Flippers), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(LightShoes), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(BunnyEars), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(PietSmietController), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Game.Manager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AnimationPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(FieldPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(BalancingPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(DebugPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(EnemyAICollisionDetect), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Patches.Flavour), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(GameNetworkManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(GrabbableObject), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(HUDManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(InventoryPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(ItemDataHandling), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(ItemDropship), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(MaskedEnemyPatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(SavePatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(MobileTerminal), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Rocket), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(LobbySetup), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(ClientSetup), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(DeathScreen), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Game.Player), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(LobbySizePatches), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Volumes), "AdvancedCompany");
				LobbySizePatches.PatchAsync();
				FieldPatches.ApplyPatches();
				Harmony.CreateAndPatchAll(typeof(PlayerControllerB), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(RoundManager), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(StartOfRound), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(AdvancedCompany.Patches.Terminal), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(TimeOfDay), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Compability), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Endscreen), "AdvancedCompany");
				Harmony.CreateAndPatchAll(typeof(Utils), "AdvancedCompany");
				Log.LogInfo((object)"Loading cosmetics...");
				foreach (string item in Directory.EnumerateFiles(Paths.PluginPath, "*.cosmetics", SearchOption.AllDirectories))
				{
					AssetBundle bundle = AssetBundle.LoadFromFile(item);
					AdvancedCompany.Lib.Cosmetics.LoadCosmeticsFromBundle(bundle);
				}
				foreach (string item2 in Directory.EnumerateFiles(Paths.PluginPath, "MoreCompany.dll", SearchOption.AllDirectories))
				{
					ExtractMoreCompanyAssets(item2);
				}
				foreach (string item3 in Directory.EnumerateFiles(Paths.PluginPath, ModpackConfig.Instance.LogoFilename.Value, SearchOption.AllDirectories))
				{
					Log.LogInfo((object)("Found a logo image at " + item3));
					try
					{
						Texture2D val = new Texture2D(1, 1, (TextureFormat)5, false);
						ImageConversion.LoadImage(val, File.ReadAllBytes(item3));
						Sprite overrideLogo = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
						AdvancedCompany.Lib.Flavour.OverrideLogo = overrideLogo;
						Log.LogInfo((object)"Successfully set logo!");
					}
					catch (Exception ex2)
					{
						Log.LogError((object)"Error while loading logo:");
						Log.LogError((object)ex2);
					}
				}
			}
			catch (Exception ex3)
			{
				Log.LogError((object)"Error while booting!");
				Log.LogError((object)ex3);
			}
		}

		private static void ExtractMoreCompanyAssets(string fileName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Log.LogMessage((object)"Found MoreCompany.dll. Extracting assets.");
			AssemblyDefinition val = AssemblyDefinition.ReadAssembly(fileName);
			Enumerator<Resource> enumerator = val.MainModule.Resources.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Resource current = enumerator.Current;
					EmbeddedResource val2 = (EmbeddedResource)(object)((current is EmbeddedResource) ? current : null);
					if (val2 != null && ((Resource)val2).Name == "MoreCompany.Resources.morecompany.cosmetics")
					{
						Log.LogMessage((object)"Found cosmetics. Loading them.");
						AssetBundle bundle = AssetBundle.LoadFromMemory(val2.GetResourceData());
						AdvancedCompany.Lib.Cosmetics.LoadCosmeticsFromBundle(bundle);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator).Dispose();
			}
		}

		private void CheckAssembly(Assembly assembly)
		{
			foreach (string ignoreAssembly in IgnoreAssemblies)
			{
				if (assembly.FullName.StartsWith(ignoreAssembly))
				{
					return;
				}
			}
			if (!AssembliesToScan.Contains(assembly))
			{
				IEnumerable<AssemblyMetadataAttribute> customAttributes = assembly.GetCustomAttributes<AssemblyMetadataAttribute>();
				bool flag = false;
				if (assembly.FullName.Contains("LethalLevelLoader"))
				{
					flag = true;
				}
				if (!flag)
				{
					foreach (AssemblyMetadataAttribute item in customAttributes)
					{
						if (item.Key == "AdvancedCompanyIgnore" && item.Value.ToLowerInvariant() == "true")
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					AssembliesToScan.Add(assembly);
					Log.LogInfo((object)("Added " + assembly.FullName + " to assemblies to scan."));
				}
				else
				{
					Log.LogWarning((object)("Assembly " + assembly.FullName + " defined AdvancedCompanyIgnore metadata. This mod might lead to config overrides not working. Be cautious about override errors."));
				}
			}
			CheckAssemblyPatches(assembly);
		}

		private void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
		{
			CheckAssembly(args.LoadedAssembly);
		}

		private static void CheckAssemblyPatches(Assembly assembly)
		{
			if (assembly.FullName.StartsWith("FuckYouMod"))
			{
				PatchMoreEmotes(assembly);
			}
		}

		private static bool Deactivate()
		{
			return false;
		}

		private static void PatchMoreEmotes(Assembly assembly)
		{
			UseAnimationOverride = true;
		}

		public static bool ShouldSaveOutfits()
		{
			return (ServerConfiguration.Instance?.General?.SaveSuitsAfterDeath).GetValueOrDefault();
		}
	}
	public class ConfigContainer : MonoBehaviour
	{
		public delegate void Add();

		public TextMeshProUGUI TitleField;

		public TextMeshProUGUI DescriptionField;

		public Transform Container;

		public GameObject SliderPrefab;

		public GameObject NumericInputPrefab;

		public GameObject TextInputPrefab;

		public GameObject TogglePrefab;

		public GameObject ItemPrefab;

		public GameObject UnlockablePrefab;

		public GameObject ScrapPrefab;

		public GameObject EnemyPrefab;

		public GameObject PerkPrefab;

		public GameObject WeatherPrefab;

		public GameObject MoonPrefab;

		public Button AddButton;

		public Add OnAdd;

		public void Start()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (!((Object)(object)AddButton != (Object)null))
			{
				return;
			}
			((UnityEvent)AddButton.onClick).AddListener((UnityAction)delegate
			{
				if (OnAdd != null)
				{
					OnAdd();
				}
			});
		}

		public ConfigContainer Initialize(string title, string description)
		{
			if ((Object)(object)TitleField != (Object)null)
			{
				((TMP_Text)TitleField).text = title;
			}
			if ((Object)(object)DescriptionField != (Object)null)
			{
				((TMP_Text)DescriptionField).text = description;
			}
			return this;
		}

		public GameObject AddEmpty()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			GameObject val = new GameObject();
			val.AddComponent<RectTransform>();
			val.transform.parent = Container;
			return val;
		}

		public ConfigMoonInput AddMoon(LobbyConfiguration.MoonConfig moonConfig, string moonName)
		{
			GameObject val = Object.Instantiate<GameObject>(MoonPrefab, Container);
			ConfigMoonInput component = val.GetComponent<ConfigMoonInput>();
			component.Initialize(moonName);
			component.SetValue(moonConfig);
			return component;
		}

		public ConfigWeatherInput AddWeather(LobbyConfiguration.WeatherConfig weatherConfig, string weatherName)
		{
			GameObject val = Object.Instantiate<GameObject>(WeatherPrefab, Container);
			ConfigWeatherInput component = val.GetComponent<ConfigWeatherInput>();
			component.Initialize(weatherName);
			component.SetValue(weatherConfig);
			return component;
		}

		public ConfigPerkInput AddPerk(LobbyConfiguration.PerkConfiguration perkConfig, string itemName)
		{
			GameObject val = Object.Instantiate<GameObject>(PerkPrefab, Container);
			ConfigPerkInput component = val.GetComponent<ConfigPerkInput>();
			component.Initialize(itemName);
			component.SetValue(perkConfig);
			return component;
		}

		public ConfigItemInput AddItem(LobbyConfiguration.ItemConfig itemConfig, string itemName)
		{
			GameObject val = Object.Instantiate<GameObject>(ItemPrefab, Container);
			ConfigItemInput component = val.GetComponent<ConfigItemInput>();
			component.Initialize(itemName);
			component.SetValue(itemConfig);
			return component;
		}

		public ConfigUnlockableInput AddUnlockable(LobbyConfiguration.UnlockableConfig unlockableConfig, string unlockableName)
		{
			GameObject val = Object.Instantiate<GameObject>(UnlockablePrefab, Container);
			ConfigUnlockableInput component = val.GetComponent<ConfigUnlockableInput>();
			component.Initialize(unlockableName);
			component.SetValue(unlockableConfig);
			return component;
		}

		public ConfigScrapInput AddScrap(LobbyConfiguration.ScrapConfig scrapConfig, string scrapName)
		{
			GameObject val = Object.Instantiate<GameObject>(ScrapPrefab, Container);
			ConfigScrapInput component = val.GetComponent<ConfigScrapInput>();
			component.Initialize(scrapName);
			component.SetValue(scrapConfig);
			return component;
		}

		public ConfigEnemyInput AddEnemy(LobbyConfiguration.EnemyConfig enemyConfig, string enemyName)
		{
			GameObject val = Object.Instantiate<GameObject>(EnemyPrefab, Container);
			ConfigEnemyInput component = val.GetComponent<ConfigEnemyInput>();
			component.Initialize(enemyName);
			component.SetValue(enemyConfig);
			return component;
		}

		public ConfigSlider AddSlider(Configuration.ConfigField field, string label, bool showReset = true)
		{
			GameObject val = Object.Instantiate<GameObject>(SliderPrefab, Container);
			ConfigSlider component = val.GetComponent<ConfigSlider>();
			component.Initialize(label, showReset);
			component.SetValue(field);
			return component;
		}

		public ConfigNumericInput AddNumericInput(Configuration.ConfigField field, string label, string unit, float valueWidth = 35f, bool showReset = true)
		{
			GameObject val = Object.Instantiate<GameObject>(NumericInputPrefab, Container);
			ConfigNumericInput component = val.GetComponent<ConfigNumericInput>();
			component.Initialize(label, unit, valueWidth, showReset);
			component.SetValue(field);
			return component;
		}

		public ConfigTextInput AddTextInput(Configuration.ConfigField field, string label, bool showReset = true)
		{
			GameObject val = Object.Instantiate<GameObject>(TextInputPrefab, Container);
			ConfigTextInput component = val.GetComponent<ConfigTextInput>();
			component.Initialize(label, showReset);
			component.SetValue(field);
			return component;
		}

		public ConfigToggle AddToggle(Configuration.ConfigField field, string label, bool showReset = true)
		{
			GameObject val = Object.Instantiate<GameObject>(TogglePrefab, Container);
			ConfigToggle component = val.GetComponent<ConfigToggle>();
			component.Initialize(label, showReset);
			component.SetValue(field);
			return component;
		}
	}
	public class ConfigEnemyInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle ActiveInput;

		public Toggle OverridePowerLevelToggle;

		public TMP_InputField PowerLevelInput;

		public Button ResetPowerLevelButton;

		private LobbyConfiguration.EnemyConfig Item;

		private void Start()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActiveInput.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.Active = val;
			});
			((UnityEvent<string>)(object)PowerLevelInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Item.PowerLevel = result;
				}
			});
			((UnityEvent<bool>)(object)OverridePowerLevelToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverridePowerLevel = val;
				UpdateValue();
			});
			((UnityEvent)ResetPowerLevelButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("PowerLevel");
				Item.Reset("OverridePowerLevel");
				UpdateValue();
			});
		}

		public void UpdateValue()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			ActiveInput.SetIsOnWithoutNotify(Item.Active);
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverridePowerLevelToggle.SetIsOnWithoutNotify(Item.OverridePowerLevel);
			PowerLevelInput.SetTextWithoutNotify(Item.OverridePowerLevel ? Item.PowerLevel.ToString(CultureInfo.InvariantCulture) : ((int)Item.Default("PowerLevel")).ToString(CultureInfo.InvariantCulture));
			((Selectable)PowerLevelInput).interactable = Item.OverridePowerLevel;
			((Graphic)PowerLevelInput.textComponent).color = (((Selectable)PowerLevelInput).interactable ? val2 : val);
		}

		public void SetValue(LobbyConfiguration.EnemyConfig config)
		{
			Item = config;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
		}
	}
	public class ConfigItemInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle ActiveInput;

		public Toggle OverridePriceToggle;

		public TMP_InputField PriceInput;

		public Button ResetPriceButton;

		public Toggle OverrideWeightToggle;

		public TMP_InputField WeightInput;

		public Button ResetWeightButton;

		public Toggle OverrideDiscountToggle;

		public TMP_InputField DiscountInput;

		public Button ResetDiscountButton;

		private LobbyConfiguration.ItemConfig Item;

		private void Start()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActiveInput.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.Active = val;
			});
			((UnityEvent<string>)(object)PriceInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result3))
				{
					Item.Price = result3;
				}
			});
			((UnityEvent<string>)(object)WeightInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result2))
				{
					Item.Weight = 1f + (float)result2 / 105f;
				}
			});
			((UnityEvent<string>)(object)DiscountInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Item.MaxDiscount = result;
				}
			});
			((UnityEvent<bool>)(object)OverridePriceToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverridePrice = val;
				UpdateValue();
			});
			((UnityEvent<bool>)(object)OverrideWeightToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverrideWeight = val;
				UpdateValue();
			});
			((UnityEvent<bool>)(object)OverrideDiscountToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverrideMaxDiscount = val;
				UpdateValue();
			});
			((UnityEvent)ResetPriceButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("Price");
				Item.Reset("OverridePrice");
				UpdateValue();
			});
			((UnityEvent)ResetWeightButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("Weight");
				Item.Reset("OverrideWeight");
				UpdateValue();
			});
			((UnityEvent)ResetDiscountButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("MaxDiscount");
				Item.Reset("MaxDiscount");
				UpdateValue();
			});
		}

		public void UpdateValue()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			ActiveInput.SetIsOnWithoutNotify(Item.Active);
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverridePriceToggle.SetIsOnWithoutNotify(Item.OverridePrice);
			PriceInput.SetTextWithoutNotify(Item.OverridePrice ? Item.Price.ToString(CultureInfo.InvariantCulture) : ((int)Item.Default("Price")).ToString(CultureInfo.InvariantCulture));
			((Selectable)PriceInput).interactable = Item.OverridePrice;
			((Graphic)PriceInput.textComponent).color = (((Selectable)PriceInput).interactable ? val2 : val);
			OverrideWeightToggle.SetIsOnWithoutNotify(Item.OverrideWeight);
			WeightInput.SetTextWithoutNotify(Item.OverrideWeight ? Mathf.RoundToInt((Item.Weight - 1f) * 105f).ToString(CultureInfo.InvariantCulture) : Mathf.RoundToInt(((float)Item.Default("Weight") - 1f) * 105f).ToString(CultureInfo.InvariantCulture));
			((Selectable)WeightInput).interactable = Item.OverrideWeight;
			((Graphic)WeightInput.textComponent).color = (((Selectable)WeightInput).interactable ? val2 : val);
			OverrideDiscountToggle.SetIsOnWithoutNotify(Item.OverrideMaxDiscount);
			DiscountInput.SetTextWithoutNotify(Item.OverrideMaxDiscount ? Item.MaxDiscount.ToString(CultureInfo.InvariantCulture) : ((int)Item.Default("MaxDiscount")).ToString(CultureInfo.InvariantCulture));
			((Selectable)DiscountInput).interactable = Item.OverrideMaxDiscount;
			((Graphic)DiscountInput.textComponent).color = (((Selectable)DiscountInput).interactable ? val2 : val);
		}

		public void SetValue(LobbyConfiguration.ItemConfig config)
		{
			Item = config;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
		}
	}
	public class ConfigMoonInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public TMP_InputField PriceInput;

		public TMP_InputField ScrapAmountInput;

		public TMP_InputField ScrapValueInput;

		public Button ResetPriceButton;

		public Button ResetScrapAmountButton;

		public Button ResetScrapValueButton;

		private LobbyConfiguration.MoonConfig Moon;

		private void Start()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			((UnityEvent<string>)(object)PriceInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result3))
				{
					Moon.Price = result3;
				}
			});
			((UnityEvent<string>)(object)ScrapAmountInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result2))
				{
					Moon.ScrapAmountModifier = (float)result2 / 100f;
				}
			});
			((UnityEvent<string>)(object)ScrapValueInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Moon.ScrapValueModifier = (float)result / 100f;
				}
			});
			((UnityEvent)ResetPriceButton.onClick).AddListener((UnityAction)delegate
			{
				Moon.Reset("Price");
				PriceInput.SetTextWithoutNotify(Moon.Price.ToString() ?? "");
			});
			((UnityEvent)ResetScrapAmountButton.onClick).AddListener((UnityAction)delegate
			{
				Moon.Reset("ScrapAmountModifier");
				ScrapAmountInput.SetTextWithoutNotify(Mathf.RoundToInt(Moon.ScrapAmountModifier * 100f).ToString() ?? "");
			});
			((UnityEvent)ResetScrapValueButton.onClick).AddListener((UnityAction)delegate
			{
				Moon.Reset("ScrapValueModifier");
				ScrapValueInput.SetTextWithoutNotify(Mathf.RoundToInt(Moon.ScrapValueModifier * 100f).ToString() ?? "");
			});
		}

		public void UpdateValue()
		{
			PriceInput.SetTextWithoutNotify(Moon.Price.ToString() ?? "");
			ScrapAmountInput.SetTextWithoutNotify(Mathf.RoundToInt(Moon.ScrapAmountModifier * 100f).ToString() ?? "");
			ScrapValueInput.SetTextWithoutNotify(Mathf.RoundToInt(Moon.ScrapValueModifier * 100f).ToString() ?? "");
		}

		public void SetValue(LobbyConfiguration.MoonConfig config)
		{
			Moon = config;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label;
		}
	}
	public class ConfigNumericInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public TextMeshProUGUI Unit;

		public TMP_InputField Input;

		public LayoutElement InputLayout;

		public Button ResetButton;

		private Configuration.ConfigField Field;

		private void Start()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent<string>)(object)Input.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Field.Value = result;
				}
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				Field.Reset();
				int num = 0;
				if (Field.Value is int num2)
				{
					num = num2;
				}
				else if (Field.Value is float num3)
				{
					num = Mathf.RoundToInt(num3);
				}
				Input.SetTextWithoutNotify(num.ToString());
			});
		}

		public void UpdateValue()
		{
			int num = 0;
			if (Field.Value is int num2)
			{
				num = num2;
			}
			else if (Field.Value is float num3)
			{
				num = Mathf.RoundToInt(num3);
			}
			Input.SetTextWithoutNotify(num.ToString());
		}

		public void SetValue(Configuration.ConfigField field)
		{
			Field = field;
			UpdateValue();
		}

		public void Initialize(string label, string unit, float inputWidth, bool showReset)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
			((TMP_Text)Unit).text = unit;
			InputLayout.preferredWidth = inputWidth;
			((Component)ResetButton).gameObject.SetActive(showReset);
		}
	}
	public class ConfigPerkInput : MonoBehaviour
	{
		private class Validator : TMP_InputValidator
		{
			public override char Validate(ref string text, ref int pos, char ch)
			{
				if ((ch >= '0' && ch <= '9') || ch == ' ' || ch == ',')
				{
					text = text.Substring(0, pos) + ch + text.Substring(pos);
					pos++;
					return ch;
				}
				return '\0';
			}
		}

		public TextMeshProUGUI Label;

		public Toggle ActiveInput;

		public TMP_InputField BaseInput;

		public TMP_InputField ChangeInput;

		public TMP_InputField CostInput;

		public Button ResetBaseButton;

		public Button ResetChangeButton;

		public Button ResetPricesButton;

		private LobbyConfiguration.PerkConfiguration Perk;

		private static Validator ValidatorInstance;

		private void Start()
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActiveInput.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Perk.Active = val;
			});
			((UnityEvent<string>)(object)BaseInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					Perk.Base = result3 / 100f;
				}
			});
			((UnityEvent<string>)(object)ChangeInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					Perk.Change = result2 / 100f;
				}
			});
			((UnityEvent<string>)(object)CostInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				string[] array = val.Split(new char[1] { ',' }, StringSplitOptions.RemoveEmptyEntries);
				List<int> list = new List<int>();
				for (int i = 0; i < array.Length; i++)
				{
					if (int.TryParse(array[i], out var result))
					{
						list.Add(result);
					}
				}
				Perk.Prices = list.ToArray();
			});
			if ((Object)(object)ValidatorInstance == (Object)null)
			{
				ValidatorInstance = ScriptableObject.CreateInstance<Validator>();
			}
			CostInput.inputValidator = (TMP_InputValidator)(object)ValidatorInstance;
			((UnityEvent)ResetBaseButton.onClick).AddListener((UnityAction)delegate
			{
				Perk.Reset("Base");
				BaseInput.SetTextWithoutNotify(((float)Mathf.RoundToInt(Perk.Base * 1000f) / 10f).ToString(CultureInfo.InvariantCulture));
			});
			((UnityEvent)ResetChangeButton.onClick).AddListener((UnityAction)delegate
			{
				Perk.Reset("Change");
				ChangeInput.SetTextWithoutNotify(((float)Mathf.RoundToInt(Perk.Change * 1000f) / 10f).ToString(CultureInfo.InvariantCulture));
			});
			((UnityEvent)ResetPricesButton.onClick).AddListener((UnityAction)delegate
			{
				Perk.Reset("Prices");
				CostInput.SetTextWithoutNotify(string.Join(", ", Perk.Prices));
			});
		}

		public void UpdateValue()
		{
			ActiveInput.SetIsOnWithoutNotify(Perk.Active);
			BaseInput.SetTextWithoutNotify(((float)Mathf.RoundToInt(Perk.Base * 1000f) / 10f).ToString(CultureInfo.InvariantCulture));
			ChangeInput.SetTextWithoutNotify(((float)Mathf.RoundToInt(Perk.Change * 1000f) / 10f).ToString(CultureInfo.InvariantCulture));
			CostInput.SetTextWithoutNotify(string.Join(", ", Perk.Prices));
		}

		public void SetValue(LobbyConfiguration.PerkConfiguration perk)
		{
			Perk = perk;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + ":";
		}
	}
	public class ConfigScrapInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle ActiveInput;

		public Toggle OverrideMinValueToggle;

		public TMP_InputField MinValueInput;

		public Button ResetMinValueButton;

		public Toggle OverrideWeightToggle;

		public TMP_InputField WeightInput;

		public Button ResetWeightButton;

		public Toggle OverrideMaxValueToggle;

		public TMP_InputField MaxValueInput;

		public Button ResetMaxValueButton;

		private LobbyConfiguration.ScrapConfig Item;

		private void Start()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActiveInput.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.Active = val;
			});
			((UnityEvent<string>)(object)WeightInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result3))
				{
					Item.Weight = 1f + (float)result3 / 105f;
				}
			});
			((UnityEvent<string>)(object)MinValueInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result2))
				{
					Item.MinValue = result2;
				}
			});
			((UnityEvent<string>)(object)MaxValueInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Item.MaxValue = result;
				}
			});
			((UnityEvent<bool>)(object)OverrideWeightToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverrideWeight = val;
				UpdateValue();
			});
			((UnityEvent<bool>)(object)OverrideMinValueToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverrideMinValue = val;
				UpdateValue();
			});
			((UnityEvent<bool>)(object)OverrideMaxValueToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Item.OverrideMaxValue = val;
				UpdateValue();
			});
			((UnityEvent)ResetWeightButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("Weight");
				Item.Reset("OverrideWeight");
				UpdateValue();
			});
			((UnityEvent)ResetMinValueButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("MinValue");
				Item.Reset("OverrideMinValue");
				UpdateValue();
			});
			((UnityEvent)ResetMaxValueButton.onClick).AddListener((UnityAction)delegate
			{
				Item.Reset("MaxValue");
				Item.Reset("MaxValue");
				UpdateValue();
			});
		}

		public void UpdateValue()
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			ActiveInput.SetIsOnWithoutNotify(Item.Active);
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverrideWeightToggle.SetIsOnWithoutNotify(Item.OverrideWeight);
			WeightInput.SetTextWithoutNotify(Item.OverrideWeight ? Mathf.RoundToInt((Item.Weight - 1f) * 105f).ToString(CultureInfo.InvariantCulture) : Mathf.RoundToInt(((float)Item.Default("Weight") - 1f) * 105f).ToString(CultureInfo.InvariantCulture));
			((Selectable)WeightInput).interactable = Item.OverrideWeight;
			((Graphic)WeightInput.textComponent).color = (((Selectable)WeightInput).interactable ? val2 : val);
			OverrideMinValueToggle.SetIsOnWithoutNotify(Item.OverrideMinValue);
			MinValueInput.SetTextWithoutNotify(Item.OverrideMinValue ? Item.MinValue.ToString(CultureInfo.InvariantCulture) : ((int)Item.Default("MinValue")).ToString(CultureInfo.InvariantCulture));
			((Selectable)MinValueInput).interactable = Item.OverrideMinValue;
			((Graphic)MinValueInput.textComponent).color = (((Selectable)MinValueInput).interactable ? val2 : val);
			OverrideMaxValueToggle.SetIsOnWithoutNotify(Item.OverrideMaxValue);
			MaxValueInput.SetTextWithoutNotify(Item.OverrideMaxValue ? Item.MaxValue.ToString(CultureInfo.InvariantCulture) : ((int)Item.Default("MaxValue")).ToString(CultureInfo.InvariantCulture));
			((Selectable)MaxValueInput).interactable = Item.OverrideMaxValue;
			((Graphic)MaxValueInput.textComponent).color = (((Selectable)MaxValueInput).interactable ? val2 : val);
		}

		public void SetValue(LobbyConfiguration.ScrapConfig config)
		{
			Item = config;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
		}
	}
	public class ConfigSlider : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Slider Slider;

		public TMP_InputField ValueField;

		public LayoutElement ValueLayout;

		public Button ResetButton;

		private Configuration.ConfigField Field;

		private void Start()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			((UnityEvent<float>)(object)Slider.onValueChanged).AddListener((UnityAction<float>)delegate(float val)
			{
				ValueField.SetTextWithoutNotify(((int)val).ToString() ?? "");
				if (Field.Value is int)
				{
					Field.Value = Mathf.RoundToInt(val / Field.Field.SliderAttribute.Conversion);
				}
				else if (Field.Value is float)
				{
					Field.Value = val / Field.Field.SliderAttribute.Conversion;
				}
			});
			((UnityEvent<string>)(object)ValueField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					Slider.SetValueWithoutNotify(result);
					if (Field.Value is int)
					{
						Field.Value = Mathf.RoundToInt(result / Field.Field.SliderAttribute.Conversion);
					}
					else if (Field.Value is float)
					{
						Field.Value = result / Field.Field.SliderAttribute.Conversion;
					}
				}
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				Field.Reset();
				float valueWithoutNotify = 0f;
				if (Field.Value is float num)
				{
					valueWithoutNotify = num * Field.Field.SliderAttribute.Conversion;
				}
				else if (Field.Value is int num2)
				{
					valueWithoutNotify = (float)num2 * Field.Field.SliderAttribute.Conversion;
				}
				Slider.SetValueWithoutNotify(valueWithoutNotify);
				ValueField.SetTextWithoutNotify(valueWithoutNotify.ToString() ?? "");
			});
		}

		public void UpdateValue()
		{
			float valueWithoutNotify = 0f;
			if (Field.Value is float num)
			{
				valueWithoutNotify = num * Field.Field.SliderAttribute.Conversion;
			}
			else if (Field.Value is int num2)
			{
				valueWithoutNotify = (float)num2 * Field.Field.SliderAttribute.Conversion;
			}
			Slider.minValue = Field.Field.SliderAttribute.MinValue * Field.Field.SliderAttribute.Conversion;
			Slider.maxValue = Field.Field.SliderAttribute.MaxValue * Field.Field.SliderAttribute.Conversion;
			((Component)ValueField).gameObject.SetActive(Field.Field.SliderAttribute.ShowValue);
			ValueLayout.preferredWidth = Field.Field.SliderAttribute.InputWidth;
			ValueLayout.minWidth = Field.Field.SliderAttribute.InputWidth;
			Slider.SetValueWithoutNotify(valueWithoutNotify);
			ValueField.SetTextWithoutNotify(valueWithoutNotify.ToString() ?? "");
		}

		public void SetValue(Configuration.ConfigField field)
		{
			Field = field;
			UpdateValue();
		}

		public void Initialize(string label, bool showReset = true)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
			((Component)ResetButton).gameObject.SetActive(showReset);
		}
	}
	public class ConfigTabContent : MonoBehaviour
	{
		public Transform Container;

		public GameObject ContainerPrefab;

		public GameObject ItemContainerPrefab;

		public GameObject UnlockableContainerPrefab;

		public GameObject PerkContainerPrefab;

		public GameObject WeatherContainerPrefab;

		public GameObject MoonContainerPrefab;

		public GameObject ScrapContainerPrefab;

		public GameObject EnemyContainerPrefab;

		public ConfigContainer AddContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(ContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		public ConfigContainer AddItemContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(ItemContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		public ConfigContainer AddUnlockableContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(UnlockableContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		public ConfigContainer AddScrapContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(ScrapContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		public ConfigContainer AddEnemyContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(EnemyContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		public ConfigContainer AddPerkContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(PerkContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}

		internal MoonsContainer AddMoonContainer(string name, string description, LobbyConfiguration.MoonsConfig config)
		{
			GameObject val = Object.Instantiate<GameObject>(MoonContainerPrefab, Container);
			MoonsContainer component = val.GetComponent<MoonsContainer>();
			foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig> moon in LobbyConfiguration.AllMoonsConfig.Moons)
			{
				component.AddMoon(moon.Key);
			}
			foreach (KeyValuePair<string, LobbyConfiguration.ScrapConfig> item in LobbyConfiguration.AllScrapConfig.Items)
			{
				component.AddScrap(item.Key);
			}
			foreach (KeyValuePair<string, LobbyConfiguration.EnemyConfig> enemy in LobbyConfiguration.AllEnemiesConfig.Enemies)
			{
				component.AddEnemy(enemy.Key);
			}
			component.Initialize(name, description);
			component.SetValue(config);
			return component;
		}

		public ConfigContainer AddWeatherContainer(string name, string description)
		{
			GameObject val = Object.Instantiate<GameObject>(WeatherContainerPrefab, Container);
			ConfigContainer component = val.GetComponent<ConfigContainer>();
			component.Initialize(name, description);
			return component;
		}
	}
	public class ConfigTextInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public TMP_InputField Input;

		public LayoutElement InputLayout;

		public Button ResetButton;

		private Configuration.ConfigField Field;

		private void Start()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent<string>)(object)Input.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				Field.Value = val;
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				Field.Reset();
				Input.SetTextWithoutNotify(Field.Value.ToString());
			});
		}

		public void UpdateValue()
		{
			Input.SetTextWithoutNotify(Field.Value.ToString());
		}

		public void SetValue(Configuration.ConfigField field)
		{
			Field = field;
			UpdateValue();
		}

		public void Initialize(string label, bool showReset = true)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
			InputLayout.preferredWidth = 100f;
			((Component)ResetButton).gameObject.SetActive(showReset);
		}
	}
	public class ConfigToggle : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle Toggle;

		public Button ResetButton;

		private Configuration.ConfigField Field;

		private void Start()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent<bool>)(object)Toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Field.Value = val;
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				Field.Reset();
				Toggle.SetIsOnWithoutNotify((bool)Field.Value);
			});
		}

		public void UpdateValue()
		{
			Toggle.SetIsOnWithoutNotify((bool)Field.Value);
		}

		public void SetValue(Configuration.ConfigField field)
		{
			Field = field;
			UpdateValue();
		}

		public void Initialize(string label, bool showReset = true)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
			((Component)ResetButton).gameObject.SetActive(showReset);
		}
	}
	public class ConfigUnlockableInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle ActiveInput;

		public Toggle OverridePriceToggle;

		public TMP_InputField PriceInput;

		public Button ResetPriceButton;

		private LobbyConfiguration.UnlockableConfig Unlockable;

		private void Start()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			((UnityEvent<bool>)(object)ActiveInput.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Unlockable.Active = val;
			});
			((UnityEvent<string>)(object)PriceInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Unlockable.Price = result;
				}
			});
			((UnityEvent<bool>)(object)OverridePriceToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Unlockable.OverridePrice = val;
				UpdateValue();
			});
			((UnityEvent)ResetPriceButton.onClick).AddListener((UnityAction)delegate
			{
				Unlockable.Reset("Price");
				Unlockable.Reset("OverridePrice");
				UpdateValue();
			});
		}

		public void UpdateValue()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			ActiveInput.SetIsOnWithoutNotify(Unlockable.Active);
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverridePriceToggle.SetIsOnWithoutNotify(Unlockable.OverridePrice);
			PriceInput.SetTextWithoutNotify(Unlockable.OverridePrice ? Unlockable.Price.ToString(CultureInfo.InvariantCulture) : ((int)Unlockable.Default("Price")).ToString(CultureInfo.InvariantCulture));
			((Selectable)PriceInput).interactable = Unlockable.OverridePrice;
			((Graphic)PriceInput.textComponent).color = (((Selectable)PriceInput).interactable ? val2 : val);
		}

		public void SetValue(LobbyConfiguration.UnlockableConfig config)
		{
			Unlockable = config;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
		}
	}
	public class ConfigWeatherInput : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle OverrideValueToggle;

		public TMP_InputField ValueInput;

		public Button ResetValueButton;

		public Toggle OverrideAmountToggle;

		public TMP_InputField AmountInput;

		public Button ResetAmountButton;

		private LobbyConfiguration.WeatherConfig Weather;

		private void Start()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			((UnityEvent<string>)(object)ValueInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result2))
				{
					Weather.ScrapValueMultiplier = (float)result2 / 100f;
				}
			});
			((UnityEvent<bool>)(object)OverrideValueToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Weather.OverrideScrapValueMultiplier = val;
				UpdateValue();
			});
			((UnityEvent<string>)(object)AmountInput.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (int.TryParse(val, out var result))
				{
					Weather.ScrapAmountMultiplier = (float)result / 100f;
				}
			});
			((UnityEvent<bool>)(object)OverrideAmountToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				Weather.OverrideScrapAmountMultiplier = val;
				UpdateValue();
			});
			((UnityEvent)ResetValueButton.onClick).AddListener((UnityAction)delegate
			{
				Weather.Reset("ScrapValueMultiplier");
				Weather.Reset("OverrideScrapValueMultiplier");
				UpdateValue();
			});
			((UnityEvent)ResetAmountButton.onClick).AddListener((UnityAction)delegate
			{
				Weather.Reset("ScrapAmountMultiplier");
				Weather.Reset("OverrideScrapAmountMultiplier");
				UpdateValue();
			});
		}

		public void UpdateValue()
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverrideValueToggle.SetIsOnWithoutNotify(Weather.OverrideScrapValueMultiplier);
			ValueInput.SetTextWithoutNotify(Weather.OverrideScrapValueMultiplier ? Mathf.RoundToInt(Weather.ScrapValueMultiplier * 100f).ToString(CultureInfo.InvariantCulture) : Mathf.RoundToInt((float)Weather.Default("ScrapValueMultiplier") * 100f).ToString(CultureInfo.InvariantCulture));
			((Selectable)ValueInput).interactable = Weather.OverrideScrapValueMultiplier;
			((Graphic)ValueInput.textComponent).color = (((Selectable)ValueInput).interactable ? val2 : val);
			OverrideAmountToggle.SetIsOnWithoutNotify(Weather.OverrideScrapAmountMultiplier);
			AmountInput.SetTextWithoutNotify(Weather.OverrideScrapAmountMultiplier ? Mathf.RoundToInt(Weather.ScrapAmountMultiplier * 100f).ToString(CultureInfo.InvariantCulture) : Mathf.RoundToInt((float)Weather.Default("ScrapAmountMultiplier") * 100f).ToString(CultureInfo.InvariantCulture));
			((Selectable)AmountInput).interactable = Weather.OverrideScrapAmountMultiplier;
			((Graphic)AmountInput.textComponent).color = (((Selectable)AmountInput).interactable ? val2 : val);
		}

		public void SetValue(LobbyConfiguration.WeatherConfig weather)
		{
			Weather = weather;
			UpdateValue();
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label + (label.EndsWith(":") ? "" : ":");
		}
	}
	public class ConfirmOverrideWindow : MonoBehaviour
	{
		public delegate void Submitted(string name);

		public delegate void Cancelled();

		public GameObject Shadow;

		public TextMeshProUGUI Text;

		public Button ConfirmButton;

		public Button CancelButton;

		[HideInInspector]
		public Submitted OnSubmitted;

		[HideInInspector]
		public Cancelled OnCancelled;

		private string Name;

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnCancelled != null)
				{
					OnCancelled();
				}
			});
			((UnityEvent)ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnSubmitted != null)
				{
					OnSubmitted(Name);
				}
			});
		}

		public void Open(string name)
		{
			Name = name;
			((TMP_Text)Text).text = "Do you really want to override \"" + name + "\"? This step is irreversible.";
			Shadow.SetActive(true);
			((Component)this).gameObject.SetActive(true);
		}

		public void Close()
		{
			Shadow.SetActive(false);
			((Component)this).gameObject.SetActive(false);
		}
	}
	public class CosmeticDatabase
	{
		public static Dictionary<CosmeticType, Dictionary<string, CosmeticInstance>> Cosmetics = new Dictionary<CosmeticType, Dictionary<string, CosmeticInstance>>
		{
			{
				CosmeticType.HAT,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.CHEST,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.HIP,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.R_LOWER_ARM,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.WRIST,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.R_SHIN,
				new Dictionary<string, CosmeticInstance>()
			},
			{
				CosmeticType.L_SHIN,
				new Dictionary<string, CosmeticInstance>()
			}
		};

		public static Dictionary<string, CosmeticInstance> AllCosmetics = new Dictionary<string, CosmeticInstance>();

		public static void AddCosmetic(CosmeticInstance instance)
		{
			if (!AllCosmetics.ContainsKey(instance.cosmeticId))
			{
				AllCosmetics.Add(instance.cosmeticId, instance);
				Cosmetics[instance.cosmeticType].Add(instance.cosmeticId, instance);
			}
		}
	}
	public class CosmeticsLoader : MonoBehaviour
	{
		public class ThreadWorker
		{
			public CosmeticsLoader Instance;

			public void Run()
			{
				string result;
				while (Instance.Files.TryDequeue(out result))
				{
					try
					{
						if (result.EndsWith(".cosmetics"))
						{
							string directoryName = Path.GetDirectoryName(result);
							string fileName = Path.GetFileName(result);
							string path = Path.Combine(directoryName, fileName + ".md5");
							string text = Path.Combine(directoryName, fileName + ".cache");
							bool flag = File.Exists(path);
							bool flag2 = File.Exists(text);
							byte[] buffer = File.ReadAllBytes(result);
							string text2 = "";
							using (MD5 mD = MD5.Create())
							{
								text2 = BitConverter.ToString(mD.ComputeHash(buffer)).Replace("-", "").ToLowerInvariant();
							}
							if (flag && flag2)
							{
								string text3 = File.ReadAllText(path).Trim().ToLowerInvariant();
								if (text2 != text3)
								{
									flag = false;
									flag2 = false;
								}
							}
							if (!flag || !flag2)
							{
								AssetsManager assetsManager = new AssetsManager();
								BundleFileInstance bundleFileInstance = assetsManager.LoadBundleFile(result);
								AssetsFileInstance assetsFileInstance = assetsManager.LoadAssetsFileFromBundle(bundleFileInstance, 0);
								foreach (AssetFileInfo assetInfo in assetsFileInstance.file.AssetInfos)
								{
									bool flag3 = false;
									AssetTypeValueField baseField = assetsManager.GetBaseField(assetsFileInstance, assetInfo);
									if (baseField["m_AssemblyName"].FieldName != "DUMMY" && baseField["m_AssemblyName"].AsString == "MoreCompany")
									{
										baseField["m_AssemblyName"].AsString = "AdvancedCompany.Unity";
										baseField["m_Namespace"].AsString = "AdvancedCompany.Cosmetics";
										flag3 = true;
									}
									if (flag3)
									{
										assetInfo.SetNewData(baseField);
									}
								}
								bundleFileInstance.file.BlockAndDirInfo.DirectoryInfos[0].SetNewData(assetsFileInstance.file);
								using (FileStream fileStream = new FileStream(text + ".uncompressed", FileMode.Create, FileAccess.Write, FileShare.Read))
								{
									using AssetsFileWriter writer = new AssetsFileWriter(fileStream);
									bundleFileInstance.file.Write(writer, 0L);
								}
								assetsManager.UnloadAll(unloadClassData: true);
								AssetBundleFile assetBundleFile = new AssetBundleFile();
								assetBundleFile.Read(new AssetsFileReader(File.OpenRead(text + ".uncompressed")));
								using (AssetsFileWriter writer2 = new AssetsFileWriter(text))
								{
									assetBundleFile.Pack(writer2, AssetBundleCompressionType.LZ4);
								}
								assetBundleFile.Close();
								File.Delete(text + ".uncompressed");
								File.WriteAllText(path, text2);
							}
							Instance.ConvertedFiles.Add(text);
						}
						Instance.Status[result] = true;
					}
					catch (Exception ex)
					{
						Debug.Log((object)ex.ToString());
						Instance.Status[result] = true;
					}
				}
			}
		}

		public GameObject Shadow;

		public RectTransform LoadingBar;

		public TextMeshProUGUI LoadingText;

		public TextMeshProUGUI Percentage;

		private HashSet<string> AddedFiles = new HashSet<string>();

		private ConcurrentBag<string> ConvertedFiles = new ConcurrentBag<string>();

		private ConcurrentQueue<string> Files = new ConcurrentQueue<string>();

		private ConcurrentDictionary<string, bool> Status = new ConcurrentDictionary<string, bool>();

		private const int MAX_THREADS = 8;

		private bool Converting = false;

		private bool Loading = false;

		private AssetBundleCreateRequest[] Loaders;

		private void Start()
		{
			if (Application.isEditor)
			{
				AddDirectory("Assets/TestCosmetics");
				StartConverting();
			}
		}

		private void Update()
		{
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			if (Converting)
			{
				int count = Status.Count;
				int num = 0;
				foreach (KeyValuePair<string, bool> item in Status)
				{
					if (item.Value)
					{
						num++;
					}
				}
				float num2 = (float)num / (float)count;
				LoadingBar.sizeDelta = new Vector2(355f * num2, LoadingBar.sizeDelta.y);
				if (num == count)
				{
					StartLoading();
				}
			}
			else
			{
				if (!Loading)
				{
					return;
				}
				float num3 = Loaders.Length;
				float num4 = 0f;
				int num5 = 0;
				for (int i = 0; i < Loaders.Length; i++)
				{
					if (((AsyncOperation)Loaders[i]).isDone)
					{
						num5++;
						num4 += 1f;
						if ((Object)(object)Loaders[i].assetBundle != (Object)null)
						{
							LoadCosmetics(Loaders[i].assetBundle);
						}
					}
					else
					{
						num4 += ((AsyncOperation)Loaders[i]).progress;
					}
				}
				float num6 = num4 / num3;
				LoadingBar.sizeDelta = new Vector2(355f * num6, LoadingBar.sizeDelta.y);
				if (num5 == Loaders.Length)
				{
					Close();
				}
			}
		}

		private void Close()
		{
			((Component)this).gameObject.SetActive(false);
			if (Application.isEditor)
			{
				Object.FindObjectOfType<PlayerSettings>().SetCosmeticsProvider(new PlayerSettings.TestCosmeticProvider());
			}
		}

		private void LoadCosmetics(AssetBundle assetBundle)
		{
			string[] allAssetNames = assetBundle.GetAllAssetNames();
			for (int i = 0; i < allAssetNames.Length; i++)
			{
				if (allAssetNames[i].EndsWith(".prefab", StringComparison.OrdinalIgnoreCase))
				{
					GameObject val = assetBundle.LoadAsset<GameObject>(allAssetNames[i]);
					((Object)val).hideFlags = (HideFlags)32;
					CosmeticInstance component = val.GetComponent<CosmeticInstance>();
					if ((Object)(object)component != (Object)null)
					{
						CosmeticDatabase.AddCosmetic(component);
					}
				}
			}
		}

		public void AddDirectory(string directory)
		{
			if (!Directory.Exists(directory))
			{
				return;
			}
			string[] files = Directory.GetFiles(directory);
			HashSet<string> hashSet = new HashSet<string>();
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			for (int i = 0; i < files.Length; i++)
			{
				if (files[i].EndsWith(".cosmetics"))
				{
					hashSet.Add(files[i]);
					AddFile(files[i]);
				}
				if (files[i].EndsWith(".cosmetics.md5"))
				{
					list.Add(files[i]);
				}
				if (files[i].EndsWith(".cosmetics.cache"))
				{
					list2.Add(files[i]);
				}
			}
			foreach (string item in list2)
			{
				if (!hashSet.Contains(item.Replace(".cosmetics.cache", ".cosmetics")))
				{
					File.Delete(item);
				}
			}
			foreach (string item2 in list)
			{
				if (!hashSet.Contains(item2.Replace(".cosmetics.md5", ".cosmetics")))
				{
					File.Delete(item2);
				}
			}
			string[] directories = Directory.GetDirectories(directory);
			for (int j = 0; j < directories.Length; j++)
			{
				AddDirectory(directories[j]);
			}
		}

		public void AddFile(string file)
		{
			if (!AddedFiles.Contains(file))
			{
				AddedFiles.Add(file);
				Files.Enqueue(file);
				Status.TryAdd(file, value: false);
			}
		}

		private void StartLoading()
		{
			((TMP_Text)LoadingText).text = "Loading cosmetics...";
			Converting = false;
			Loading = true;
			string[] array = ConvertedFiles.ToArray();
			Loaders = (AssetBundleCreateRequest[])(object)new AssetBundleCreateRequest[array.Length];
			for (int i = 0; i < array.Length; i++)
			{
				Loaders[i] = AssetBundle.LoadFromFileAsync(array[i]);
			}
		}

		public void StartConverting()
		{
			Converting = true;
			for (int i = 0; i < 8; i++)
			{
				ThreadWorker @object = new ThreadWorker
				{
					Instance = this
				};
				Thread thread = new Thread(@object.Run);
				thread.Start();
			}
		}
	}
	public class DressUpDrag : MonoBehaviour, IDragHandler, IEventSystemHandler
	{
		public bool Dragging = false;

		public Vector2 Delta = Vector2.zero;

		private Vector2 LastDrag = Vector2.zero;

		private bool DraggedLastFrame = false;

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_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)
			if (Dragging)
			{
				Delta = LastDrag - eventData.position;
			}
			Dragging = true;
			DraggedLastFrame = true;
			LastDrag = eventData.position;
			((AbstractEventData)eventData).Use();
		}

		private void LateUpdate()
		{
			//IL_0002: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Delta = Vector2.zero;
			if (!DraggedLastFrame)
			{
				Dragging = false;
				LastDrag = Vector2.zero;
			}
			DraggedLastFrame = false;
		}
	}
	public class NewPresetWindow : MonoBehaviour
	{
		public delegate void Submitted(string value);

		public delegate void Cancelled();

		public GameObject Shadow;

		public TMP_InputField NameInput;

		public Button ConfirmButton;

		public Button CancelButton;

		[HideInInspector]
		public Submitted OnSubmitted;

		[HideInInspector]
		public Cancelled OnCancelled;

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnCancelled != null)
				{
					OnCancelled();
				}
			});
			((UnityEvent)ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnSubmitted != null)
				{
					OnSubmitted(NameInput.text.Trim());
				}
			});
		}

		public void Open(string name)
		{
			Shadow.SetActive(true);
			((Component)this).gameObject.SetActive(true);
			NameInput.text = name;
		}

		public void Close()
		{
			Shadow.SetActive(false);
			((Component)this).gameObject.SetActive(false);
		}
	}
	public class RemovePresetWindow : MonoBehaviour
	{
		public delegate void Submitted();

		public delegate void Cancelled();

		public GameObject Shadow;

		public TextMeshProUGUI Text;

		public Button ConfirmButton;

		public Button CancelButton;

		[HideInInspector]
		public Submitted OnSubmitted;

		[HideInInspector]
		public Cancelled OnCancelled;

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnCancelled != null)
				{
					OnCancelled();
				}
			});
			((UnityEvent)ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnSubmitted != null)
				{
					OnSubmitted();
				}
			});
		}

		public void Open(string name)
		{
			((TMP_Text)Text).text = "Do you really want to remove \"" + name + "\"? This step is irreversible.";
			Shadow.SetActive(true);
			((Component)this).gameObject.SetActive(true);
		}

		public void Close()
		{
			Shadow.SetActive(false);
			((Component)this).gameObject.SetActive(false);
		}
	}
	public class RenamePresetWindow : MonoBehaviour
	{
		public delegate void Submitted(string value);

		public delegate void Cancelled();

		public GameObject Shadow;

		public TMP_InputField NameInput;

		public Button ConfirmButton;

		public Button CancelButton;

		[HideInInspector]
		public Submitted OnSubmitted;

		[HideInInspector]
		public Cancelled OnCancelled;

		private void Start()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			((UnityEvent)CancelButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnCancelled != null)
				{
					OnCancelled();
				}
			});
			((UnityEvent)ConfirmButton.onClick).AddListener((UnityAction)delegate
			{
				Close();
				if (OnSubmitted != null)
				{
					OnSubmitted(NameInput.text.Trim());
				}
			});
		}

		public void Open(string name)
		{
			Shadow.SetActive(true);
			((Component)this).gameObject.SetActive(true);
			NameInput.text = name;
		}

		public void Close()
		{
			Shadow.SetActive(false);
			((Component)this).gameObject.SetActive(false);
		}
	}
	[HarmonyPatch]
	public class Utils
	{
		private static List<GameObject> NetworkPrefabs = new List<GameObject>();

		private static bool NetworkManagerStarted = false;

		public static NetworkManager NetworkManager;

		public static void AddNetworkPrefab(GameObject go)
		{
			NetworkPrefabs.Add(go);
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void Start(GameNetworkManager __instance)
		{
			for (int i = 0; i < NetworkPrefabs.Count; i++)
			{
				NetworkManager.Singleton.AddNetworkPrefab(NetworkPrefabs[i]);
			}
		}
	}
}
namespace AdvancedCompany.Unity.UI
{
	[ExecuteInEditMode]
	public class DoomDigits : MonoBehaviour
	{
		public RectTransform LayoutGroup;

		private int LastNumber = -1;

		public int Number = 0;

		public bool AddPercentage = false;

		public bool Reverse = false;

		public Color Color;

		public Image[] Images;

		[Header("0-9%")]
		public Sprite[] Sprites;

		private void Update()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			if (Number == LastNumber || Sprites.Length < 11)
			{
				return;
			}
			string text = Number.ToString();
			if (AddPercentage)
			{
				text += "%";
			}
			for (int i = 0; i < Images.Length; i++)
			{
				if (text.Length > i)
				{
					char c = text[Reverse ? (text.Length - 1 - i) : i];
					((Behaviour)Images[i]).enabled = true;
					((Graphic)Images[i]).color = Color;
					switch (c)
					{
					case '0':
						Images[i].sprite = Sprites[0];
						break;
					case '1':
						Images[i].sprite = Sprites[1];
						break;
					case '2':
						Images[i].sprite = Sprites[2];
						break;
					case '3':
						Images[i].sprite = Sprites[3];
						break;
					case '4':
						Images[i].sprite = Sprites[4];
						break;
					case '5':
						Images[i].sprite = Sprites[5];
						break;
					case '6':
						Images[i].sprite = Sprites[6];
						break;
					case '7':
						Images[i].sprite = Sprites[7];
						break;
					case '8':
						Images[i].sprite = Sprites[8];
						break;
					case '9':
						Images[i].sprite = Sprites[9];
						break;
					case '%':
						Images[i].sprite = Sprites[10];
						break;
					}
					RectTransform rectTransform = ((Graphic)Images[i]).rectTransform;
					Rect rect = Images[i].sprite.rect;
					float width = ((Rect)(ref rect)).width;
					rect = Images[i].sprite.rect;
					float num = width / ((Rect)(ref rect)).height;
					rect = LayoutGroup.rect;
					float num2 = num * ((Rect)(ref rect)).height;
					rect = LayoutGroup.rect;
					rectTransform.sizeDelta = new Vector2(num2, ((Rect)(ref rect)).height);
				}
				else
				{
					((Behaviour)Images[i]).enabled = false;
				}
			}
			LastNumber = Number;
		}
	}
	[CreateAssetMenu(menuName = "DoomFont", order = 2, fileName = "DoomFont")]
	public class DoomFont : ScriptableObject
	{
		public List<char> Chars;

		public List<Sprite> Sprites;

		public int CharHeight;

		public Sprite GetSprite(char c)
		{
			int num = Chars.IndexOf(c);
			if (num > -1)
			{
				return Sprites[num];
			}
			return null;
		}
	}
	public class DoomHUD : MonoBehaviour
	{
		public enum SpritePhase
		{
			LEFT,
			STRAIGHT,
			RIGHT,
			MANIAC,
			DAMAGE,
			SECRET,
			DEAD
		}

		public Sprite[] LeftSprites;

		public Sprite[] StraightSprites;

		public Sprite[] RightSprites;

		public Sprite[] ManiacSprites;

		public Sprite[] DamageSprites;

		public Sprite SecretSprite;

		public Sprite DeadSprite;

		private SpritePhase _HeadPhase;

		public Image PlayerHead;

		private int _HP;

		private int _Armor;

		private int _BulletsAmmo = 0;

		private int _ShellsAmmo = 100;

		private int _RocketsAmmo = 0;

		private int _CellsAmmo;

		private bool _HasArms2;

		private bool _HasArms3;

		private bool _HasArms4;

		private bool _HasArms5;

		private bool _HasArms6;

		private bool _HasArms7;

		public Color ActiveColor;

		public Color InactiveColor;

		public DoomText Arms2Text;

		public DoomText Arms3Text;

		public DoomText Arms4Text;

		public DoomText Arms5Text;

		public DoomText Arms6Text;

		public DoomText Arms7Text;

		public DoomText HealthText;

		public DoomText AmmoText;

		public DoomText ArmorText;

		public DoomText BulletsText;

		public DoomText ShellsText;

		public DoomText RocketsText;

		public DoomText CellsText;

		public int CurrentWeapon = 4;

		public Animator ShotgunAnimator;

		private float ShootPhase = 0f;

		public SpritePhase HeadPhase
		{
			get
			{
				return _HeadPhase;
			}
			set
			{
				_HeadPhase = value;
				UpdateSprite();
			}
		}

		public int HP
		{
			get
			{
				return _HP;
			}
			set
			{
				_HP = value;
				HealthText.Text = value + "%";
				UpdateSprite();
			}
		}

		public int Armor
		{
			get
			{
				return _Armor;
			}
			set
			{
				_Armor = value;
				ArmorText.Text = value + "%";
			}
		}

		public int BulletsAmmo
		{
			get
			{
				return _BulletsAmmo;
			}
			set
			{
				_BulletsAmmo = value;
				BulletsText.Text = value.ToString();
			}
		}

		public int ShellsAmmo
		{
			get
			{
				return _ShellsAmmo;
			}
			set
			{
				_ShellsAmmo = value;
				ShellsText.Text = value.ToString();
				if (CurrentWeapon == 4)
				{
					AmmoText.Text = value.ToString();
				}
			}
		}

		public int RocketsAmmo
		{
			get
			{
				return _RocketsAmmo;
			}
			set
			{
				_RocketsAmmo = value;
				RocketsText.Text = value.ToString();
			}
		}

		public int CellsAmmo
		{
			get
			{
				return _CellsAmmo;
			}
			set
			{
				_CellsAmmo = value;
				CellsText.Text = value.ToString();
			}
		}

		public bool HasArms2
		{
			get
			{
				return _HasArms2;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms2 = value;
				Arms2Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public bool HasArms3
		{
			get
			{
				return _HasArms3;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms3 = value;
				Arms3Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public bool HasArms4
		{
			get
			{
				return _HasArms4;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms4 = value;
				Arms4Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public bool HasArms5
		{
			get
			{
				return _HasArms5;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms5 = value;
				Arms5Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public bool HasArms6
		{
			get
			{
				return _HasArms6;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms6 = value;
				Arms6Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public bool HasArms7
		{
			get
			{
				return _HasArms7;
			}
			set
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				_HasArms7 = value;
				Arms7Text.Color = (value ? ActiveColor : InactiveColor);
			}
		}

		public void UpdateSprite()
		{
			int num = 4 - Mathf.RoundToInt((float)HP / 100f * 4f);
			if (_HeadPhase == SpritePhase.LEFT)
			{
				PlayerHead.sprite = LeftSprites[num];
			}
			else if (_HeadPhase == SpritePhase.STRAIGHT)
			{
				PlayerHead.sprite = StraightSprites[num];
			}
			else if (_HeadPhase == SpritePhase.RIGHT)
			{
				PlayerHead.sprite = RightSprites[num];
			}
			else if (_HeadPhase == SpritePhase.DAMAGE)
			{
				PlayerHead.sprite = DamageSprites[num];
			}
			else if (_HeadPhase == SpritePhase.MANIAC)
			{
				PlayerHead.sprite = ManiacSprites[num];
			}
			else if (_HeadPhase == SpritePhase.DEAD)
			{
				PlayerHead.sprite = DeadSprite;
			}
			else if (_HeadPhase == SpritePhase.SECRET)
			{
				PlayerHead.sprite = SecretSprite;
			}
		}

		private void Start()
		{
			BulletsText.Text = BulletsAmmo.ToString();
			ShellsText.Text = ShellsAmmo.ToString();
			RocketsText.Text = RocketsAmmo.ToString();
			CellsText.Text = CellsAmmo.ToString();
			if (CurrentWeapon == 4)
			{
				AmmoText.Text = ShellsAmmo.ToString();
			}
			HealthText.Text = HP + "%";
			ArmorText.Text = Armor + "%";
		}

		public bool Shoot()
		{
			if (ShellsAmmo > 1)
			{
				if (ShootPhase > 0f)
				{
					return false;
				}
				ShotgunAnimator.SetTrigger("Shoot");
				ShellsAmmo -= 2;
				ShootPhase = 1.4f;
				return true;
			}
			return false;
		}

		private void Update()
		{
			if (ShootPhase > 0f)
			{
				ShootPhase -= Time.deltaTime;
			}
		}
	}
	public class DoomSuperShotgun : MonoBehaviour
	{
		public AudioSource Audio;

		public void Shoot()
		{
			Audio.Play();
		}
	}
	[ExecuteInEditMode]
	[RequireComponent(typeof(HorizontalLayoutGroup))]
	public class DoomText : MonoBehaviour
	{
		protected HorizontalLayoutGroup LayoutGroup;

		protected RectTransform RectTransform;

		private string LastText = "";

		public DoomFont Font;

		public string Text = "";

		public float Spacing = 0f;

		public bool Shadow = false;

		public Color ShadowColor;

		public Color Color;

		protected List<Image> Images = new List<Image>();

		protected List<Image> Shadows = new List<Image>();

		protected List<RectTransform> Containers = new List<RectTransform>();

		private void Update()
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: 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_0581: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0701: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Unknown result type (might be due to invalid IL or missing references)
			//IL_074e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			if (Text == LastText || (Object)(object)Font == (Object)null)
			{
				return;
			}
			if ((Object)(object)RectTransform == (Object)null)
			{
				RectTransform = ((Component)this).GetComponent<RectTransform>();
			}
			if ((Object)(object)LayoutGroup == (Object)null)
			{
				LayoutGroup = ((Component)this).GetComponent<HorizontalLayoutGroup>();
			}
			for (int i = 0; i < Text.Length; i++)
			{
				if (i >= Containers.Count || i >= Images.Count || i >= Shadows.Count || (Object)(object)Images[i] == (Object)null || (Object)(object)Shadows[i] == (Object)null || (Object)(object)Containers[i] == (Object)null)
				{
					Transform val = null;
					if (((Component)this).transform.childCount > i)
					{
						val = ((Component)this).transform.GetChild(i);
					}
					else
					{
						GameObject val2 = new GameObject("Letter" + i);
						RectTransform val3 = val2.AddComponent<RectTransform>();
						((Transform)val3).SetParent((Transform)(object)RectTransform);
						((Transform)val3).localScale = Vector3.one;
						val3.anchoredPosition3D = Vector3.zero;
						val = ((Component)val3).transform;
					}
					((Object)val).name = "Letter" + i;
					if (i >= Containers.Count)
					{
						Containers.Add(((Component)val).GetComponent<RectTransform>());
					}
					else
					{
						Containers[i] = ((Component)val).GetComponent<RectTransform>();
					}
					Transform val4 = null;
					if (val.childCount > 0)
					{
						val4 = val.GetChild(0);
					}
					else
					{
						GameObject val5 = new GameObject("Shadow");
						RectTransform val6 = val5.AddComponent<RectTransform>();
						((Transform)val6).SetParent(val);
						((Transform)val6).localScale = Vector3.one;
						val6.anchoredPosition3D = Vector3.zero;
						val4 = ((Component)val6).transform;
					}
					Transform val7 = null;
					if (val.childCount > 1)
					{
						val7 = val.GetChild(1);
					}
					else
					{
						GameObject val8 = new GameObject("Face");
						RectTransform val9 = val8.AddComponent<RectTransform>();
						((Transform)val9).SetParent(val);
						((Transform)val9).localScale = Vector3.one;
						val9.anchoredPosition3D = Vector3.zero;
						val7 = ((Component)val9).transform;
					}
					Image val10 = ((Component)val4).gameObject.GetComponent<Image>();
					if ((Object)(object)val10 == (Object)null)
					{
						val10 = ((Component)val4).gameObject.AddComponent<Image>();
					}
					Image val11 = ((Component)val7).gameObject.GetComponent<Image>();
					if ((Object)(object)val11 == (Object)null)
					{
						val11 = ((Component)val7).gameObject.AddComponent<Image>();
					}
					if (i >= Images.Count)
					{
						Images.Add(val11);
					}
					else
					{
						Images[i] = val11;
					}
					if (i >= Shadows.Count)
					{
						Shadows.Add(val10);
					}
					else
					{
						Shadows[i] = val10;
					}
				}
			}
			for (int num = Containers.Count - 1; num >= Text.Length; num--)
			{
				if ((Object)(object)Containers[num] != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)((Component)Containers[num]).gameObject);
				}
			}
			if (Containers.Count > Text.Length)
			{
				Containers.RemoveRange(Text.Length, Containers.Count - Text.Length);
			}
			if (Images.Count > Text.Length)
			{
				Images.RemoveRange(Text.Length, Images.Count - Text.Length);
			}
			if (Shadows.Count > Text.Length)
			{
				Shadows.RemoveRange(Text.Length, Shadows.Count - Text.Length);
			}
			((HorizontalOrVerticalLayoutGroup)LayoutGroup).spacing = Spacing;
			Vector2 sizeDelta = default(Vector2);
			for (int j = 0; j < Containers.Count; j++)
			{
				if (j < Text.Length)
				{
					if (!((Component)Containers[j]).gameObject.activeSelf)
					{
						((Component)Containers[j]).gameObject.SetActive(true);
					}
					Images[j].sprite = Font.GetSprite(Text[j]);
					Rect rect = Images[j].sprite.rect;
					float num2 = ((Rect)(ref rect)).width / (float)Font.CharHeight;
					rect = RectTransform.rect;
					float num3 = num2 * ((Rect)(ref rect)).height;
					rect = RectTransform.rect;
					float height = ((Rect)(ref rect)).height;
					rect = Images[j].sprite.rect;
					((Vector2)(ref sizeDelta))..ctor(num3, height * (((Rect)(ref rect)).height / (float)Font.CharHeight));
					Containers[j].sizeDelta = sizeDelta;
					((Graphic)Images[j]).rectTransform.sizeDelta = sizeDelta;
					((Graphic)Images[j]).color = Color;
					if (Shadow)
					{
						if (!((Component)Shadows[j]).gameObject.activeSelf)
						{
							((Component)Shadows[j]).gameObject.SetActive(true);
						}
						Shadows[j].sprite = Images[j].sprite;
						((Graphic)Shadows[j]).rectTransform.sizeDelta = sizeDelta;
						((Graphic)Shadows[j]).rectTransform.anchorMax = Vector2.op_Implicit(new Vector3(0f, 1f));
						((Graphic)Shadows[j]).rectTransform.anchorMin = Vector2.op_Implicit(new Vector3(0f, 1f));
						((Graphic)Shadows[j]).rectTransform.pivot = Vector2.op_Implicit(new Vector3(0f, 1f));
						((Graphic)Shadows[j]).color = ShadowColor;
						((Graphic)Shadows[j]).rectTransform.anchoredPosition = Vector2.op_Implicit(new Vector3(Spacing, 0f - Spacing, 0f));
					}
					else if (((Component)Shadows[j]).gameObject.activeSelf)
					{
						((Component)Shadows[j]).gameObject.SetActive(false);
					}
				}
				else if ((Object)(object)Containers[j] != (Object)null && ((Component)Containers[j]).gameObject.activeSelf)
				{
					((Component)Containers[j]).gameObject.SetActive(false);
				}
			}
		}
	}
}
namespace AdvancedCompany.Unity.Moons
{
	internal class EnemyItem : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle OverrideRarityToggle;

		public TMP_InputField RarityField;

		public Button ResetButton;

		private LobbyConfiguration.MoonConfig.EnemyTableItem Config;

		private void Awake()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			Color inactiveTextColor = new Color(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color activeTextColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			((UnityEvent<bool>)(object)OverrideRarityToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00b9: 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)
				if (Config != null)
				{
					Config.Override = val;
					((Selectable)RarityField).interactable = val;
					RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
					((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)RarityField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (Config != null && int.TryParse(val, out var result))
				{
					Config.Rarity = result;
				}
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				Config.Override = false;
				Config.Reset("Rarity");
				OverrideRarityToggle.SetIsOnWithoutNotify(false);
				((Selectable)RarityField).interactable = Config.Override;
				RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
				((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? activeTextColor : inactiveTextColor);
			});
		}

		public void SetValue(LobbyConfiguration.MoonConfig.EnemyTableItem enemyConfig)
		{
			Config = enemyConfig;
			UpdateValues();
		}

		public void UpdateValues()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverrideRarityToggle.SetIsOnWithoutNotify(Config.Override);
			((Selectable)RarityField).interactable = Config.Override;
			RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
			((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? val2 : val);
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label;
		}
	}
	internal class MoonItem : MonoBehaviour
	{
		public Image ActiveBackground;

		public TextMeshProUGUI Label;

		public Button Button;

		public LobbyConfiguration.MoonConfig Config;

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label;
		}

		public void SetValue(LobbyConfiguration.MoonConfig config)
		{
			Config = config;
		}

		public void Select()
		{
			((Component)ActiveBackground).gameObject.SetActive(true);
		}

		public void Unselect()
		{
			((Component)ActiveBackground).gameObject.SetActive(false);
		}
	}
	internal class MoonsContainer : MonoBehaviour
	{
		public TextMeshProUGUI TitleLabel;

		public TextMeshProUGUI DescriptionLabel;

		public GameObject MoonItem;

		public Transform MoonsTransform;

		public Dictionary<string, MoonItem> Moons = new Dictionary<string, MoonItem>();

		public GameObject EnemyItem;

		public GameObject ScrapItem;

		public Toggle PriceOverrideToggle;

		public TMP_InputField PriceField;

		public Button ResetPriceButton;

		public Toggle DungeonSizeOverrideToggle;

		public TMP_InputField DungeonSizeField;

		public Button ResetDungeonSizeButton;

		public Toggle MinScrapAmountOverrideToggle;

		public TMP_InputField MinScrapAmountField;

		public Button ResetMinScrapAmountButton;

		public Toggle MaxScrapAmountOverrideToggle;

		public TMP_InputField MaxScrapAmountField;

		public Button ResetMaxScrapAmountButton;

		public Toggle ScrapAmountModifierOverrideToggle;

		public TMP_InputField ScrapAmountModifierField;

		public Button ResetScrapAmountModifierButton;

		public Toggle ScrapValueModifierOverrideToggle;

		public TMP_InputField ScrapValueModifierField;

		public Button ResetScrapValueModifierButton;

		public Transform LootTableContainer;

		public Dictionary<string, ScrapItem> LootTableItems = new Dictionary<string, ScrapItem>();

		public Toggle DaytimeEnemiesMaxPowerOverrideToggle;

		public TMP_InputField DaytimeEnemiesMaxPowerField;

		public Button ResetDaytimeEnemiesMaxPowerButton;

		public Toggle DaytimeEnemiesProbabilityOverrideToggle;

		public TMP_InputField DaytimeEnemiesProbabilityField;

		public Button ResetDaytimeEnemiesProbabilityButton;

		public Transform DaytimeEnemiesContainer;

		public Dictionary<string, EnemyItem> DaytimeEnemies = new Dictionary<string, EnemyItem>();

		public Toggle OutsideEnemiesMaxPowerOverrideToggle;

		public TMP_InputField OutsideEnemiesMaxPowerField;

		public Button ResetOutsideEnemiesMaxPowerButton;

		public Transform OutsideEnemiesContainer;

		public Dictionary<string, EnemyItem> OutsideEnemies = new Dictionary<string, EnemyItem>();

		public Toggle InsideEnemiesMaxPowerOverrideToggle;

		public TMP_InputField InsideEnemiesMaxPowerField;

		public Button ResetInsideEnemiesMaxPowerButton;

		public Toggle InsideEnemiesProbabilityOverrideToggle;

		public TMP_InputField InsideEnemiesProbabilityField;

		public Button ResetInsideEnemiesProbabilityButton;

		public Transform InsideEnemiesContainer;

		public Dictionary<string, EnemyItem> InsideEnemies = new Dictionary<string, EnemyItem>();

		private MoonItem Selected;

		private LobbyConfiguration.MoonsConfig Config;

		public void Awake()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Expected O, but got Unknown
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Expected O, but got Unknown
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			Color inactiveTextColor = new Color(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color activeTextColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			((UnityEvent<bool>)(object)PriceOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverridePrice = val;
					((Selectable)PriceField).interactable = val;
					PriceField.SetTextWithoutNotify(Selected.Config.OverridePrice ? Selected.Config.Price.ToString() : Selected.Config.Default("Price").ToString());
					((Graphic)PriceField.textComponent).color = (((Selectable)PriceField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)PriceField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result11))
				{
					Selected.Config.Price = result11;
				}
			});
			((UnityEvent)ResetPriceButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverridePrice = false;
				Selected.Config.Reset("Price");
				PriceOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)PriceField).interactable = false;
				PriceField.SetTextWithoutNotify(Selected.Config.OverridePrice ? Selected.Config.Price.ToString() : Selected.Config.Default("Price").ToString());
				((Graphic)PriceField.textComponent).color = (((Selectable)PriceField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)DungeonSizeOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideDungeonSize = val;
					((Selectable)DungeonSizeField).interactable = val;
					DungeonSizeField.SetTextWithoutNotify(Selected.Config.OverrideDungeonSize ? Selected.Config.DungeonSize.ToString(CultureInfo.InvariantCulture) : ((float)Selected.Config.Default("DungeonSize")).ToString(CultureInfo.InvariantCulture));
					((Graphic)DungeonSizeField.textComponent).color = (((Selectable)DungeonSizeField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)DungeonSizeField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result10))
				{
					Selected.Config.DungeonSize = result10;
				}
			});
			((UnityEvent)ResetDungeonSizeButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideDungeonSize = false;
				Selected.Config.Reset("DungeonSize");
				DungeonSizeOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)DungeonSizeField).interactable = false;
				DungeonSizeField.SetTextWithoutNotify(Selected.Config.OverrideDungeonSize ? Selected.Config.DungeonSize.ToString(CultureInfo.InvariantCulture) : ((float)Selected.Config.Default("DungeonSize")).ToString(CultureInfo.InvariantCulture));
				((Graphic)DungeonSizeField.textComponent).color = (((Selectable)DungeonSizeField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)MinScrapAmountOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideMinScrapAmount = val;
					((Selectable)MinScrapAmountField).interactable = val;
					MinScrapAmountField.SetTextWithoutNotify(Selected.Config.OverrideMinScrapAmount ? Selected.Config.MinScrapAmount.ToString() : Selected.Config.Default("MinScrapAmount").ToString());
					((Graphic)MinScrapAmountField.textComponent).color = (((Selectable)MinScrapAmountField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)MinScrapAmountField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result9))
				{
					Selected.Config.MinScrapAmount = result9;
				}
			});
			((UnityEvent)ResetMinScrapAmountButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideMinScrapAmount = false;
				Selected.Config.Reset("MinScrapAmount");
				MinScrapAmountOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)MinScrapAmountField).interactable = false;
				MinScrapAmountField.SetTextWithoutNotify(Selected.Config.OverrideMinScrapAmount ? Selected.Config.MinScrapAmount.ToString() : Selected.Config.Default("MinScrapAmount").ToString());
				((Graphic)MinScrapAmountField.textComponent).color = (((Selectable)MinScrapAmountField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)MaxScrapAmountOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideMaxScrapAmount = val;
					((Selectable)MaxScrapAmountField).interactable = val;
					MaxScrapAmountField.SetTextWithoutNotify(Selected.Config.OverrideMaxScrapAmount ? Selected.Config.MaxScrapAmount.ToString() : Selected.Config.Default("MaxScrapAmount").ToString());
					((Graphic)MaxScrapAmountField.textComponent).color = (((Selectable)MaxScrapAmountField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)MaxScrapAmountField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result8))
				{
					Selected.Config.MaxScrapAmount = result8;
				}
			});
			((UnityEvent)ResetMaxScrapAmountButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideMaxScrapAmount = false;
				Selected.Config.Reset("MaxScrapAmount");
				MaxScrapAmountOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)MaxScrapAmountField).interactable = false;
				MaxScrapAmountField.SetTextWithoutNotify(Selected.Config.OverrideMaxScrapAmount ? Selected.Config.MaxScrapAmount.ToString() : Selected.Config.Default("MaxScrapAmount").ToString());
				((Graphic)MaxScrapAmountField.textComponent).color = (((Selectable)MaxScrapAmountField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)ScrapAmountModifierOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideScrapAmountModifier = val;
					((Selectable)ScrapAmountModifierField).interactable = val;
					ScrapAmountModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapAmountModifier ? Selected.Config.ScrapAmountModifier : ((float)Selected.Config.Default("ScrapAmountModifier"))) * 100f).ToString());
					((Graphic)ScrapAmountModifierField.textComponent).color = (((Selectable)ScrapAmountModifierField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)ScrapAmountModifierField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result7))
				{
					Selected.Config.ScrapAmountModifier = (float)result7 / 100f;
				}
			});
			((UnityEvent)ResetScrapAmountModifierButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideScrapAmountModifier = false;
				Selected.Config.Reset("ScrapAmountModifier");
				ScrapAmountModifierOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)ScrapAmountModifierField).interactable = false;
				ScrapAmountModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapAmountModifier ? Selected.Config.ScrapAmountModifier : ((float)Selected.Config.Default("ScrapAmountModifier"))) * 100f).ToString());
				((Graphic)ScrapAmountModifierField.textComponent).color = (((Selectable)ScrapAmountModifierField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)ScrapValueModifierOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideScrapValueModifier = val;
					((Selectable)ScrapValueModifierField).interactable = val;
					ScrapValueModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapValueModifier ? Selected.Config.ScrapValueModifier : ((float)Selected.Config.Default("ScrapValueModifier"))) * 100f).ToString());
					((Graphic)ScrapValueModifierField.textComponent).color = (((Selectable)ScrapValueModifierField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)ScrapValueModifierField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result6))
				{
					Selected.Config.ScrapValueModifier = (float)result6 / 100f;
				}
			});
			((UnityEvent)ResetScrapValueModifierButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideScrapValueModifier = false;
				Selected.Config.Reset("ScrapValueModifier");
				ScrapValueModifierOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)ScrapValueModifierField).interactable = false;
				ScrapValueModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapValueModifier ? Selected.Config.ScrapValueModifier : ((float)Selected.Config.Default("ScrapValueModifier"))) * 100f).ToString());
				((Graphic)ScrapValueModifierField.textComponent).color = (((Selectable)ScrapValueModifierField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)DaytimeEnemiesMaxPowerOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideDaytimeEnemiesMaxPower = val;
					((Selectable)DaytimeEnemiesMaxPowerField).interactable = val;
					DaytimeEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideDaytimeEnemiesMaxPower ? Selected.Config.DaytimeEnemiesMaxPower.ToString() : Selected.Config.Default("DaytimeEnemiesMaxPower").ToString());
					((Graphic)DaytimeEnemiesMaxPowerField.textComponent).color = (((Selectable)DaytimeEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)DaytimeEnemiesMaxPowerField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result5))
				{
					Selected.Config.DaytimeEnemiesMaxPower = result5;
				}
			});
			((UnityEvent)ResetDaytimeEnemiesMaxPowerButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideDaytimeEnemiesMaxPower = false;
				Selected.Config.Reset("DaytimeEnemiesMaxPower");
				DaytimeEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)DaytimeEnemiesMaxPowerField).interactable = false;
				DaytimeEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideDaytimeEnemiesMaxPower ? Selected.Config.DaytimeEnemiesMaxPower.ToString() : Selected.Config.Default("DaytimeEnemiesMaxPower").ToString());
				((Graphic)DaytimeEnemiesMaxPowerField.textComponent).color = (((Selectable)DaytimeEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)DaytimeEnemiesProbabilityOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideDaytimeEnemiesProbability = val;
					((Selectable)DaytimeEnemiesProbabilityField).interactable = val;
					DaytimeEnemiesProbabilityField.SetTextWithoutNotify(Selected.Config.OverrideDaytimeEnemiesProbability ? Selected.Config.DaytimeEnemiesProbability.ToString() : Selected.Config.Default("DaytimeEnemiesProbability").ToString());
					((Graphic)DaytimeEnemiesProbabilityField.textComponent).color = (((Selectable)DaytimeEnemiesProbabilityField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)DaytimeEnemiesProbabilityField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
				{
					Selected.Config.DaytimeEnemiesProbability = result4;
				}
			});
			((UnityEvent)ResetDaytimeEnemiesProbabilityButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideDaytimeEnemiesProbability = false;
				Selected.Config.Reset("DaytimeEnemiesProbability");
				DaytimeEnemiesProbabilityOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)DaytimeEnemiesProbabilityField).interactable = false;
				DaytimeEnemiesProbabilityField.SetTextWithoutNotify(Selected.Config.OverrideDaytimeEnemiesProbability ? Selected.Config.DaytimeEnemiesProbability.ToString() : Selected.Config.Default("DaytimeEnemiesProbability").ToString());
				((Graphic)DaytimeEnemiesProbabilityField.textComponent).color = (((Selectable)DaytimeEnemiesProbabilityField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)OutsideEnemiesMaxPowerOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideOutsideEnemiesMaxPower = val;
					((Selectable)OutsideEnemiesMaxPowerField).interactable = val;
					OutsideEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideOutsideEnemiesMaxPower ? Selected.Config.OutsideEnemiesMaxPower.ToString() : Selected.Config.Default("OutsideEnemiesMaxPower").ToString());
					((Graphic)OutsideEnemiesMaxPowerField.textComponent).color = (((Selectable)OutsideEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)OutsideEnemiesMaxPowerField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result3))
				{
					Selected.Config.OutsideEnemiesMaxPower = result3;
				}
			});
			((UnityEvent)ResetOutsideEnemiesMaxPowerButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideOutsideEnemiesMaxPower = false;
				Selected.Config.Reset("OutsideEnemiesMaxPower");
				OutsideEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)OutsideEnemiesMaxPowerField).interactable = false;
				OutsideEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideOutsideEnemiesMaxPower ? Selected.Config.OutsideEnemiesMaxPower.ToString() : Selected.Config.Default("OutsideEnemiesMaxPower").ToString());
				((Graphic)OutsideEnemiesMaxPowerField.textComponent).color = (((Selectable)OutsideEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)InsideEnemiesMaxPowerOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideInsideEnemiesMaxPower = val;
					((Selectable)InsideEnemiesMaxPowerField).interactable = val;
					InsideEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideInsideEnemiesMaxPower ? Selected.Config.InsideEnemiesMaxPower.ToString() : Selected.Config.Default("InsideEnemiesMaxPower").ToString());
					((Graphic)InsideEnemiesMaxPowerField.textComponent).color = (((Selectable)InsideEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)InsideEnemiesMaxPowerField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && int.TryParse(val, out var result2))
				{
					Selected.Config.InsideEnemiesMaxPower = result2;
				}
			});
			((UnityEvent)ResetInsideEnemiesMaxPowerButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideInsideEnemiesMaxPower = false;
				Selected.Config.Reset("InsideEnemiesMaxPower");
				InsideEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)InsideEnemiesMaxPowerField).interactable = false;
				InsideEnemiesMaxPowerField.SetTextWithoutNotify(Selected.Config.OverrideInsideEnemiesMaxPower ? Selected.Config.InsideEnemiesMaxPower.ToString() : Selected.Config.Default("InsideEnemiesMaxPower").ToString());
				((Graphic)InsideEnemiesMaxPowerField.textComponent).color = (((Selectable)InsideEnemiesMaxPowerField).interactable ? activeTextColor : inactiveTextColor);
			});
			((UnityEvent<bool>)(object)InsideEnemiesProbabilityOverrideToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Selected != (Object)null && Selected.Config != null)
				{
					Selected.Config.OverrideInsideEnemiesProbability = val;
					((Selectable)InsideEnemiesProbabilityField).interactable = val;
					InsideEnemiesProbabilityField.SetTextWithoutNotify(Selected.Config.OverrideInsideEnemiesProbability ? Selected.Config.InsideEnemiesProbability.ToString() : Selected.Config.Default("InsideEnemiesProbability").ToString());
					((Graphic)InsideEnemiesProbabilityField.textComponent).color = (((Selectable)InsideEnemiesProbabilityField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)InsideEnemiesProbabilityField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if ((Object)(object)Selected != (Object)null && Selected.Config != null && float.TryParse(val, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					Selected.Config.InsideEnemiesProbability = result;
				}
			});
			((UnityEvent)ResetInsideEnemiesProbabilityButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				Selected.Config.OverrideInsideEnemiesProbability = false;
				Selected.Config.Reset("InsideEnemiesProbability");
				InsideEnemiesProbabilityOverrideToggle.SetIsOnWithoutNotify(false);
				((Selectable)InsideEnemiesProbabilityField).interactable = false;
				InsideEnemiesProbabilityField.SetTextWithoutNotify(Selected.Config.OverrideInsideEnemiesProbability ? Selected.Config.InsideEnemiesProbability.ToString() : Selected.Config.Default("InsideEnemiesProbability").ToString());
				((Graphic)InsideEnemiesProbabilityField.textComponent).color = (((Selectable)InsideEnemiesProbabilityField).interactable ? activeTextColor : inactiveTextColor);
			});
		}

		public void SetValue(LobbyConfiguration.MoonsConfig moons)
		{
			Config = moons;
			UpdateValues();
		}

		internal void ApplyValues(MoonItem moon)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			if (moon.Config == null)
			{
				return;
			}
			PriceOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverridePrice);
			PriceField.SetTextWithoutNotify(moon.Config.OverridePrice ? moon.Config.Price.ToString() : moon.Config.Default("Price").ToString());
			((Selectable)PriceField).interactable = moon.Config.OverridePrice;
			((Graphic)PriceField.textComponent).color = (((Selectable)PriceField).interactable ? val2 : val);
			DungeonSizeOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideDungeonSize);
			DungeonSizeField.SetTextWithoutNotify(moon.Config.OverrideDungeonSize ? moon.Config.DungeonSize.ToString() : moon.Config.Default("DungeonSize").ToString());
			((Selectable)DungeonSizeField).interactable = moon.Config.OverrideDungeonSize;
			((Graphic)DungeonSizeField.textComponent).color = (((Selectable)DungeonSizeField).interactable ? val2 : val);
			MinScrapAmountOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideMinScrapAmount);
			MinScrapAmountField.SetTextWithoutNotify(moon.Config.OverrideMinScrapAmount ? moon.Config.MinScrapAmount.ToString() : moon.Config.Default("MinScrapAmount").ToString());
			((Selectable)MinScrapAmountField).interactable = moon.Config.OverrideMinScrapAmount;
			((Graphic)MinScrapAmountField.textComponent).color = (((Selectable)MinScrapAmountField).interactable ? val2 : val);
			MaxScrapAmountOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideMaxScrapAmount);
			MaxScrapAmountField.SetTextWithoutNotify(moon.Config.OverrideMaxScrapAmount ? moon.Config.MaxScrapAmount.ToString() : moon.Config.Default("MaxScrapAmount").ToString());
			((Selectable)MaxScrapAmountField).interactable = moon.Config.OverrideMaxScrapAmount;
			((Graphic)MaxScrapAmountField.textComponent).color = (((Selectable)MaxScrapAmountField).interactable ? val2 : val);
			ScrapAmountModifierOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideScrapAmountModifier);
			ScrapAmountModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapAmountModifier ? Selected.Config.ScrapAmountModifier : ((float)Selected.Config.Default("ScrapAmountModifier"))) * 100f).ToString());
			((Selectable)ScrapAmountModifierField).interactable = moon.Config.OverrideScrapAmountModifier;
			((Graphic)ScrapAmountModifierField.textComponent).color = (((Selectable)ScrapAmountModifierField).interactable ? val2 : val);
			ScrapValueModifierOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideScrapValueModifier);
			ScrapValueModifierField.SetTextWithoutNotify(Mathf.RoundToInt((Selected.Config.OverrideScrapValueModifier ? Selected.Config.ScrapValueModifier : ((float)Selected.Config.Default("ScrapValueModifier"))) * 100f).ToString());
			((Selectable)ScrapValueModifierField).interactable = moon.Config.OverrideScrapValueModifier;
			((Graphic)ScrapValueModifierField.textComponent).color = (((Selectable)ScrapValueModifierField).interactable ? val2 : val);
			DaytimeEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideDaytimeEnemiesMaxPower);
			DaytimeEnemiesMaxPowerField.SetTextWithoutNotify(moon.Config.OverrideDaytimeEnemiesMaxPower ? moon.Config.DaytimeEnemiesMaxPower.ToString() : moon.Config.Default("DaytimeEnemiesMaxPower").ToString());
			((Selectable)DaytimeEnemiesMaxPowerField).interactable = moon.Config.OverrideDaytimeEnemiesMaxPower;
			((Graphic)DaytimeEnemiesMaxPowerField.textComponent).color = (((Selectable)DaytimeEnemiesMaxPowerField).interactable ? val2 : val);
			DaytimeEnemiesProbabilityOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideDaytimeEnemiesProbability);
			DaytimeEnemiesProbabilityField.SetTextWithoutNotify(moon.Config.OverrideDaytimeEnemiesProbability ? moon.Config.DaytimeEnemiesProbability.ToString() : moon.Config.Default("DaytimeEnemiesProbability").ToString());
			((Selectable)DaytimeEnemiesProbabilityField).interactable = moon.Config.OverrideDaytimeEnemiesProbability;
			((Graphic)DaytimeEnemiesProbabilityField.textComponent).color = (((Selectable)DaytimeEnemiesProbabilityField).interactable ? val2 : val);
			OutsideEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideOutsideEnemiesMaxPower);
			OutsideEnemiesMaxPowerField.SetTextWithoutNotify(moon.Config.OverrideOutsideEnemiesMaxPower ? moon.Config.OutsideEnemiesMaxPower.ToString() : moon.Config.Default("OutsideEnemiesMaxPower").ToString());
			((Selectable)OutsideEnemiesMaxPowerField).interactable = moon.Config.OverrideOutsideEnemiesMaxPower;
			((Graphic)OutsideEnemiesMaxPowerField.textComponent).color = (((Selectable)OutsideEnemiesMaxPowerField).interactable ? val2 : val);
			InsideEnemiesMaxPowerOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideInsideEnemiesMaxPower);
			InsideEnemiesMaxPowerField.SetTextWithoutNotify(moon.Config.OverrideInsideEnemiesMaxPower ? moon.Config.InsideEnemiesMaxPower.ToString() : moon.Config.Default("InsideEnemiesMaxPower").ToString());
			((Selectable)InsideEnemiesMaxPowerField).interactable = moon.Config.OverrideInsideEnemiesMaxPower;
			((Graphic)InsideEnemiesMaxPowerField.textComponent).color = (((Selectable)InsideEnemiesMaxPowerField).interactable ? val2 : val);
			InsideEnemiesProbabilityOverrideToggle.SetIsOnWithoutNotify(moon.Config.OverrideInsideEnemiesProbability);
			InsideEnemiesProbabilityField.SetTextWithoutNotify(moon.Config.OverrideInsideEnemiesProbability ? moon.Config.InsideEnemiesProbability.ToString() : moon.Config.Default("InsideEnemiesProbability").ToString());
			((Selectable)InsideEnemiesProbabilityField).interactable = moon.Config.OverrideInsideEnemiesProbability;
			((Graphic)InsideEnemiesProbabilityField.textComponent).color = (((Selectable)InsideEnemiesProbabilityField).interactable ? val2 : val);
			foreach (KeyValuePair<string, ScrapItem> lootTableItem in LootTableItems)
			{
				if (moon.Config.LootTable.ContainsKey(lootTableItem.Key))
				{
					lootTableItem.Value.SetValue(moon.Config.LootTable[lootTableItem.Key]);
				}
			}
			foreach (KeyValuePair<string, EnemyItem> daytimeEnemy in DaytimeEnemies)
			{
				if (moon.Config.DaytimeEnemies.ContainsKey(daytimeEnemy.Key))
				{
					daytimeEnemy.Value.SetValue(moon.Config.DaytimeEnemies[daytimeEnemy.Key]);
				}
			}
			foreach (KeyValuePair<string, EnemyItem> outsideEnemy in OutsideEnemies)
			{
				if (moon.Config.OutsideEnemies.ContainsKey(outsideEnemy.Key))
				{
					outsideEnemy.Value.SetValue(moon.Config.OutsideEnemies[outsideEnemy.Key]);
				}
			}
			foreach (KeyValuePair<string, EnemyItem> insideEnemy in InsideEnemies)
			{
				if (moon.Config.InsideEnemies.ContainsKey(insideEnemy.Key))
				{
					insideEnemy.Value.SetValue(moon.Config.InsideEnemies[insideEnemy.Key]);
				}
			}
		}

		public void AddMoon(string moonName)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(MoonItem, MoonsTransform);
			MoonItem comp = val.GetComponent<MoonItem>();
			comp.Initialize(moonName);
			comp.Unselect();
			((UnityEvent)comp.Button.onClick).AddListener((UnityAction)delegate
			{
				SelectMoon(comp);
			});
			Moons.Add(moonName, comp);
			if (Moons.Count == 1)
			{
				SelectMoon(comp);
			}
		}

		public void SelectMoon(MoonItem item)
		{
			if ((Object)(object)Selected != (Object)null)
			{
				Selected.Unselect();
			}
			item.Select();
			Selected = item;
			ApplyValues(Selected);
		}

		public void AddScrap(string scrapName)
		{
			GameObject val = Object.Instantiate<GameObject>(ScrapItem, LootTableContainer);
			ScrapItem component = val.GetComponent<ScrapItem>();
			component.Initialize(scrapName);
			LootTableItems.Add(scrapName, component);
		}

		public void AddEnemy(string enemyName)
		{
			GameObject val = Object.Instantiate<GameObject>(EnemyItem, DaytimeEnemiesContainer);
			EnemyItem component = val.GetComponent<EnemyItem>();
			component.Initialize(enemyName);
			DaytimeEnemies.Add(enemyName, component);
			GameObject val2 = Object.Instantiate<GameObject>(EnemyItem, OutsideEnemiesContainer);
			EnemyItem component2 = val2.GetComponent<EnemyItem>();
			component2.Initialize(enemyName);
			OutsideEnemies.Add(enemyName, component2);
			GameObject val3 = Object.Instantiate<GameObject>(EnemyItem, InsideEnemiesContainer);
			EnemyItem component3 = val3.GetComponent<EnemyItem>();
			component3.Initialize(enemyName);
			InsideEnemies.Add(enemyName, component3);
		}

		public void Initialize(string title, string description)
		{
			((TMP_Text)TitleLabel).text = title;
			((TMP_Text)DescriptionLabel).text = description;
		}

		public void UpdateValues()
		{
			foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig> moon in Config.Moons)
			{
				if (Moons.ContainsKey(moon.Key))
				{
					Moons[moon.Key].SetValue(moon.Value);
					if ((Object)(object)Selected == (Object)(object)Moons[moon.Key])
					{
						ApplyValues(Moons[moon.Key]);
					}
				}
			}
		}
	}
	internal class ScrapItem : MonoBehaviour
	{
		public TextMeshProUGUI Label;

		public Toggle OverrideRarityToggle;

		public TMP_InputField RarityField;

		public Button ResetButton;

		private LobbyConfiguration.MoonConfig.LootTableItem Config;

		private void Awake()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			Color inactiveTextColor = new Color(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color activeTextColor = new Color(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			((UnityEvent<bool>)(object)OverrideRarityToggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
			{
				//IL_00b9: 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)
				if (Config != null)
				{
					Config.Override = val;
					((Selectable)RarityField).interactable = val;
					RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
					((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? activeTextColor : inactiveTextColor);
				}
			});
			((UnityEvent<string>)(object)RarityField.onValueChanged).AddListener((UnityAction<string>)delegate(string val)
			{
				if (Config != null && int.TryParse(val, out var result))
				{
					Config.Rarity = result;
				}
			});
			((UnityEvent)ResetButton.onClick).AddListener((UnityAction)delegate
			{
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				Config.Override = false;
				Config.Reset("Rarity");
				OverrideRarityToggle.SetIsOnWithoutNotify(false);
				((Selectable)RarityField).interactable = Config.Override;
				RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
				((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? activeTextColor : inactiveTextColor);
			});
		}

		public void SetValue(LobbyConfiguration.MoonConfig.LootTableItem itemConfig)
		{
			Config = itemConfig;
			UpdateValues();
		}

		public void UpdateValues()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			Color val = default(Color);
			((Color)(ref val))..ctor(66f / 85f, 0.3019608f, 0.05490196f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(10f / 51f, 10f / 51f, 10f / 51f, 1f);
			OverrideRarityToggle.SetIsOnWithoutNotify(Config.Override);
			((Selectable)RarityField).interactable = Config.Override;
			RarityField.SetTextWithoutNotify(Config.Override ? Config.Rarity.ToString() : Config.Default("Rarity").ToString());
			((Graphic)RarityField.textComponent).color = (((Selectable)RarityField).interactable ? val2 : val);
		}

		public void Initialize(string label)
		{
			((TMP_Text)Label).text = label;
		}
	}
}
namespace AdvancedCompany.Cosmetics
{
	public enum CosmeticType
	{
		HAT,
		WRIST,
		CHEST,
		R_LOWER_ARM,
		HIP,
		L_SHIN,
		R_SHIN
	}
	public class CosmeticInstance : MonoBehaviour
	{
		public CosmeticType cosmeticType;

		public string cosmeticId;

		public Texture2D icon;
	}
}
namespace AdvancedCompany.UI
{
	[Bootable]
	[Requires(typeof(ClientConfiguration))]
	[Requires(typeof(ClientConfigurationProvider))]
	[LoadAssets]
	[HarmonyPatch]
	public class ClientSetup
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BaseSettings<PlayerConfiguration>.Continue <>9__8_0;

			public static BaseSettings<PlayerConfiguration>.Cancel <>9__8_1;

			public static UnityAction <>9__8_2;

			public static BaseSettings<PlayerConfiguration>.Continue <>9__9_0;

			public static BaseSettings<PlayerConfiguration>.Cancel <>9__9_1;

			public static UnityAction <>9__9_2;

			internal void <InitializeInGame>b__8_0(PlayerConfiguration configuration, string presetName)
			{
				ClientConfiguration.Instance.CopyFrom(configuration);
				AdvancedCompany.Game.Player.GetPlayer(GameNetworkManager.Instance.localPlayerController).SetCosmetics(ClientConfiguration.Instance.Cosmetics.ActivatedCosmetics.ToArray());
				InventoryPatches.ArrangeHotbar(Perks.InventorySlots());
				SelectedPreset = presetName;
				try
				{
					string fullPath = Path.GetFullPath(Paths.PluginPath + "/../presets/advancedcompany/selected");
					File.WriteAllText(fullPath, presetName);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while saving selected preset:");
					Plugin.Log.LogError((object)ex);
				}
			}

			internal void <InitializeInGame>b__8_1()
			{
				InventoryPatches.ArrangeHotbar(Perks.InventorySlots());
			}

			internal void <InitializeInGame>b__8_2()
			{
				ClientScreen.SetActive(true);
				Settings.SetCosmeticsProvider(new PlayerSettings.TestCosmeticProvider());
				Settings.SetConfiguration(ClientConfigurationProvider.Instance);
				Settings.SelectPreset(SelectedPreset);
			}

			internal void <Initialize>b__9_0(PlayerConfiguration configuration, string presetName)
			{
				ClientConfiguration.Instance.CopyFrom(configuration);
				SelectedPreset = presetName;
				try
				{
					string fullPath = Path.GetFullPath(Paths.PluginPath + "/../presets/advancedcompany/selected");
					File.WriteAllText(fullPath, presetName);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while saving selected preset:");
					Plugin.Log.LogError((object)ex);
				}
			}

			internal void <Initialize>b__9_1()
			{
			}

			internal void <Initialize>b__9_2()
			{
				ClientScreen.SetActive(true);
				Settings.SetCosmeticsProvider(new PlayerSettings.TestCosmeticProvider());
				Settings.SetConfiguration(ClientConfigurationProvider.Instance);
				Settings.SelectPreset(SelectedPreset);
			}
		}

		private static GameObject ClientScreenPrefab;

		private static MenuManager MenuManagerInstance;

		private static GameObject ClientScreen;

		private static PlayerSettings Settings;

		private static string SelectedPreset = "";

		public static void Boot()
		{
			string fullPath = Path.GetFullPath(Paths.PluginPath + "/../presets/advancedcompany/selected");
			if (File.Exists(fullPath))
			{
				string name = (SelectedPreset = File.ReadAllText(fullPath));
				BaseSettings<PlayerConfiguration>.Preset preset = ClientConfigurationProvider.Instance.GetPreset(name);
				if (preset != null)
				{
					ClientConfiguration.Instance.CopyFrom(preset.Configuration);
				}
				else
				{
					ClientConfiguration.Instance.CopyFrom(ClientConfigurationProvider.Instance.GetPresets()[0].Configuration);
				}
			}
			else
			{
				ClientConfiguration.Instance.CopyFrom(ClientConfigurationProvider.Instance.GetPresets()[0].Configuration);
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			ClientScreenPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/ClientScreen.prefab");
		}

		[HarmonyPatch(typeof(QuickMenuManager), "CloseQuickMenu")]
		[HarmonyPostfix]
		public static void CloseQuickMenu(QuickMenuManager __instance)
		{
			Settings.Close();
		}

		[HarmonyPatch(typeof(QuickMenuManager), "Start")]
		[HarmonyPostfix]
		public static void InitializeInGame(QuickMenuManager __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			ClientScreen = Object.Instantiate<GameObject>(ClientScreenPrefab, __instance.mainButtonsPanel.transform.parent);
			ClientScreen.transform.localScale = new Vector3(1f, 1f, 1f);
			Settings = ClientScreen.GetComponent<PlayerSettings>();
			ClientScreen.SetActive(false);
			PlayerSettings settings = Settings;
			settings.OnContinue = (BaseSettings<PlayerConfiguration>.Continue)Delegate.Combine(settings.OnContinue, (BaseSettings<PlayerConfiguration>.Continue)delegate(PlayerConfiguration configuration, string presetName)
			{
				ClientConfiguration.Instance.CopyFrom(configuration);
				AdvancedCompany.Game.Player.GetPlayer(GameNetworkManager.Instance.localPlayerController).SetCosmetics(ClientConfiguration.Instance.Cosmetics.ActivatedCosmetics.ToArray());
				InventoryPatches.ArrangeHotbar(Perks.InventorySlots());
				SelectedPreset = presetName;
				try
				{
					string fullPath = Path.GetFullPath(Paths.PluginPath + "/../presets/advancedcompany/selected");
					File.WriteAllText(fullPath, presetName);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while saving selected preset:");
					Plugin.Log.LogError((object)ex);
				}
			});
			PlayerSettings settings2 = Settings;
			settings2.OnCancel = (BaseSettings<PlayerConfiguration>.Cancel)Delegate.Combine(settings2.OnCancel, (BaseSettings<PlayerConfiguration>.Cancel)delegate
			{
				InventoryPatches.ArrangeHotbar(Perks.InventorySlots());
			});
			Transform transform = __instance.mainButtonsPanel.transform;
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (((Object)child).name == "Resume" || ((Object)child).name == "InvitePlayers" || ((Object)child).name == "Settings")
				{
					Transform transform2 = ((Component)child).transform;
					transform2.localPosition += new Vector3(0f, 97f, 0f);
				}
				if (!(((Object)child).name == "Settings"))
				{
					continue;
				}
				GameObject val = Object.Instantiate<GameObject>(((Component)child).gameObject, child.parent);
				((Object)val).name = "AdvancedCompany settings";
				val.transform.localPosition = ((Component)child).transform.localPosition + new Vector3(0f, -97f, 0f);
				Button component = val.GetComponent<Button>();
				component.onClick = new ButtonClickedEvent();
				((UnityEventBase)component.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = component.onClick;
				object obj = <>c.<>9__8_2;
				if (obj == null)
				{
					UnityAction val2 = delegate
					{
						ClientScreen.SetActive(true);
						Settings.SetCosmeticsProvider(new PlayerSettings.TestCosmeticProvider());
						Settings.SetConfiguration(ClientConfigurationProvider.Instance);
						Settings.SelectPreset(SelectedPreset);
					};
					<>c.<>9__8_2 = val2;
					obj = (object)val2;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				((TMP_Text)((Component)component).GetComponentInChildren<TextMeshProUGUI>()).text = "> AdvancedCompany";
			}
		}

		[HarmonyPatch(typeof(MenuManager), "Start")]
		[HarmonyPrefix]
		public static void Initialize(MenuManager __instance)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			Canvas componentInParent = __instance.menuButtons.GetComponentInParent<Canvas>();
			Transform val = ((Component)componentInParent).transform.Find("MenuContainer").Find("MainButtons");
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			ClientScreen = Object.Instantiate<GameObject>(ClientScreenPrefab, ((Component)componentInParent).transform);
			ClientScreen.transform.localScale = new Vector3(1f, 1f, 1f);
			Settings = ClientScreen.GetComponent<PlayerSettings>();
			ClientScreen.SetActive(false);
			PlayerSettings settings = Settings;
			settings.OnContinue = (BaseSettings<PlayerConfiguration>.Continue)Delegate.Combine(settings.OnContinue, (BaseSettings<PlayerConfiguration>.Continue)delegate(PlayerConfiguration configuration, string presetName)
			{
				ClientConfiguration.Instance.CopyFrom(configuration);
				SelectedPreset = presetName;
				try
				{
					string fullPath = Path.GetFullPath(Paths.PluginPath + "/../presets/advancedcompany/selected");
					File.WriteAllText(fullPath, presetName);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while saving selected preset:");
					Plugin.Log.LogError((object)ex);
				}
			});
			PlayerSettings settings2 = Settings;
			settings2.OnCancel = (BaseSettings<PlayerConfiguration>.Cancel)Delegate.Combine(settings2.OnCancel, (BaseSettings<PlayerConfiguration>.Cancel)delegate
			{
			});
			for (int i = 0; i < val.childCount; i++)
			{
				Transform child = val.GetChild(i);
				if (((Object)child).name == "HostButton" || ((Object)child).name == "JoinACrew" || ((Object)child).name == "StartLAN" || ((Object)child).name == "SettingsButton")
				{
					Transform transform = ((Component)child).transform;
					transform.localPosition += new Vector3(0f, 39f, 0f);
				}
				if (!(((Object)child).name == "SettingsButton"))
				{
					continue;
				}
				GameObject val2 = Object.Instantiate<GameObject>(((Component)child).gameObject, child.parent);
				val2.transform.localPosition = ((Component)child).transform.localPosition + new Vector3(0f, -39f, 0f);
				((Object)val2).name = "AdvancedCompany settings";
				((TMP_Text)val2.GetComponentInChildren<TextMeshProUGUI>()).text = "> AdvancedCompany settings";
				Button component = val2.GetComponent<Button>();
				component.onClick = new ButtonClickedEvent();
				((UnityEventBase)component.onClick).RemoveAllListeners();
				ButtonClickedEvent onClick = component.onClick;
				object obj = <>c.<>9__9_2;
				if (obj == null)
				{
					UnityAction val3 = delegate
					{
						ClientScreen.SetActive(true);
						Settings.SetCosmeticsProvider(new PlayerSettings.TestCosmeticProvider());
						Settings.SetConfiguration(ClientConfigurationProvider.Instance);
						Settings.SelectPreset(SelectedPreset);
					};
					<>c.<>9__9_2 = val3;
					obj = (object)val3;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
			}
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	public class DeathScreen
	{
		public class SpectatorBox
		{
			public PlayerControllerB Player;

			public GameObject Container;

			public RawImage Avatar;

			public Animator Animator;
		}

		private static GameObject PlayerBoxPrefab;

		private static GridLayoutGroup GridLayout;

		private static Dictionary<ulong, SpectatorBox> Spectators = new Dictionary<ulong, SpectatorBox>();

		public static void LoadAssets(AssetBundle assets)
		{
			PlayerBoxPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/PlayerBox.prefab");
		}

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPrefix]
		public static void Init(HUDManager __instance)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)__instance.SpectateBoxesContainer).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)((Transform)component).parent).GetComponent<RectTransform>();
			RectTransform component3 = ((Component)((Transform)component2).parent).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.offsetMin = new Vector2(0f, 0f);
			component2.offsetMax = new Vector2(0f, 0f);
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.offsetMin = new Vector2(0f, 0f);
			component3.offsetMax = new Vector2(0f, 0f);
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(0f, 0f);
			component.offsetMin = new Vector2(15f, 15f);
			component.offsetMax = new Vector2(-15f, 115f);
			GridLayout = ((Component)component).gameObject.AddComponent<GridLayoutGroup>();
			GridLayout.spacing = new Vector2(5f, 0f);
			GridLayout.constraint = (Constraint)2;
			GridLayout.constraintCount = 1;
			GridLayout.startCorner = (Corner)2;
			((LayoutGroup)GridLayout).childAlignment = (TextAnchor)6;
		}

		[HarmonyPatch(typeof(HUDManager), "RemoveSpectateUI")]
		[HarmonyPrefix]
		public static void RemoveSpectateUI()
		{
			foreach (KeyValuePair<ulong, SpectatorBox> spectator in Spectators)
			{
				Object.Destroy((Object)(object)spectator.Value.Container);
			}
			Spectators.Clear();
		}

		[HarmonyPatch(typeof(HUDManager), "Update")]
		[HarmonyPrefix]
		private static void Update()
		{
			if ((Object)(object)StartOfRound.Instance.voiceChatModule == (Object)null)
			{
				return;
			}
			bool flag = false;
			List<ulong> list = new List<ulong>();
			foreach (KeyValuePair<ulong, SpectatorBox> spectator in Spectators)
			{
				if ((Object)(object)spectator.Value.Container == (Object)null)
				{
					list.Add(spectator.Key);
					continue;
				}
				PlayerControllerB player = spectator.Value.Player;
				if (!player.isPlayerControlled && !player.isPlayerDead)
				{
					continue;
				}
				if ((Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					if (!string.IsNullOrEmpty(StartOfRound.Instance.voiceChatModule.LocalPlayerName))
					{
						VoicePlayerState val = StartOfRound.Instance.voiceChatModule.FindPlayer(StartOfRound.Instance.voiceChatModule.LocalPlayerName);
						if (val != null)
						{
							spectator.Value.Animator.SetFloat("Volume", (StartOfRound.Instance.voiceChatModule.IsMuted || !val.IsSpeaking || val.Amplitude < 0.005f) ? 0f : (val.Amplitude * 2f));
						}
					}
				}
				else if (player.voicePlayerState == null)
				{
					if (!flag)
					{
						flag = true;
						StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
					}
				}
				else
				{
					VoicePlayerState voicePlayerState = player.voicePlayerState;
					spectator.Value.Animator.SetFloat("Volume", (!voicePlayerState.IsSpeaking || voicePlayerState.IsLocallyMuted || voicePlayerState.Amplitude < 0.005f) ? 0f : (voicePlayerState.Amplitude / Mathf.Max(voicePlayerState.Volume, 0.01f) * 2f));
				}
			}
			foreach (ulong item in list)
			{
				Spectators.Remove(item);
			}
			UpdateLayoutSize();
		}

		private static void UpdateLayoutSize()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			int num = ((Component)GridLayout).transform.childCount - 4;
			Rect rect = ((Component)GridLayout).GetComponent<RectTransform>().rect;
			float num2 = ((Rect)(ref rect)).width / (float)num;
			num2 -= 5f;
			if (num2 > 70f)
			{
				num2 = 70f;
			}
			GridLayout.cellSize = new Vector2(num2, num2);
		}

		[HarmonyPatch(typeof(HUDManager), "UpdateBoxesSpectateUI")]
		[HarmonyPrefix]
		public static bool UpdateBoxes(HUDManager __instance)
		{
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
				if (!val.isPlayerDead)
				{
					if (!val.isPlayerControlled && Spectators.ContainsKey(val.playerClientId))
					{
						Object.Destroy((Object)(object)Spectators[val.playerClientId].Container);
						Spectators.Remove(val.playerClientId);
					}
					continue;
				}
				if (Spectators.ContainsKey(val.playerClientId))
				{
					if ((Object)(object)Spectators[val.playerClientId].Container == (Object)null)
					{
						Spectators.Remove(val.playerClientId);
					}
					else if (!Spectators[val.playerClientId].Container.activeSelf)
					{
						Spectators[val.playerClientId].Container.SetActive(true);
					}
					continue;
				}
				GameObject val2 = Object.Instantiate<GameObject>(PlayerBoxPrefab, __instance.SpectateBoxesContainer, false);
				val2.transform.localScale = Vector3.one;
				val2.SetActive(true);
				SpectatorBox spectatorBox = new SpectatorBox
				{
					Container = val2,
					Animator = val2.GetComponent<Animator>(),
					Player = val,
					Avatar = ((Component)val2.transform.GetChild(0).GetChild(2)).GetComponent<RawImage>()
				};
				Spectators[val.playerClientId] = spectatorBox;
				if (!GameNetworkManager.Instance.disableSteam)
				{
					Texture2D avatar = PlayerControllerB.GetAvatar(val);
					if ((Object)(object)avatar != (Object)null)
					{
						spectatorBox.Avatar.texture = (Texture)(object)PlayerControllerB.GetAvatar(val);
					}
				}
			}
			UpdateLayoutSize();
			return false;
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	public class Endscreen
	{
		private static GameObject Container;

		public static Endscreen Instance;

		private static GameObject PerformanceReportPrefab;

		private static GameObject DeadContainerPrefab;

		private static GameObject MissingContainerPrefab;

		private static GameObject NoteContainerPrefab;

		private static Transform AllDead;

		private static Transform PlayerNoteContainer;

		private static Transform DeadNoteContainer;

		private static Transform MissingTitle;

		private static Transform MissingScrollBox;

		private static Transform MissingNoteContainer;

		private static Transform CollectedLabel;

		private static Transform CollectedLine;

		private static TextMeshProUGUI CollectedText;

		private static TextMeshProUGUI TotalText;

		private static Transform ScrapLost;

		private static TextMeshProUGUI ScrapLostText;

		private static TextMeshProUGUI GradeText;

		private static int CollectedScrap;

		private static int TotalScrap;

		private static string Grade;

		private static bool AreAllDead;

		private static Dictionary<ulong, string> CachedDeathReasons = new Dictionary<ulong, string>();

		private static MethodInfo OpenEndgameMenuMethod = typeof(Endscreen).GetMethod("Open", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
		[HarmonyPrefix]
		public static void GetCoronerDeathMessages(HUDManager __instance)
		{
			CachedDeathReasons.Clear();
			if (!Chainloader.PluginInfos.ContainsKey("com.elitemastereric.coroner"))
			{
				return;
			}
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
				try
				{
					CachedDeathReasons[val.playerClientId] = CoronerDeathReason(val);
				}
				catch (Exception)
				{
				}
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			PerformanceReportPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/PerformanceReport.prefab");
			DeadContainerPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/DeadContainer.prefab");
			MissingContainerPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/MissingContainer.prefab");
			NoteContainerPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/NoteContainer.prefab");
		}

		private static string GetDeathReason(PlayerControllerB controller)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected I4, but got Unknown
			if (AdvancedCompany.Network.Manager.Lobby.LateJoiners.Contains((int)controller.playerClientId))
			{
				return "Joined late";
			}
			if (CachedDeathReasons.ContainsKey(controller.playerClientId))
			{
				return CachedDeathReasons[controller.playerClientId];
			}
			if (Chainloader.PluginInfos.ContainsKey("com.elitemastereric.coroner"))
			{
				try
				{
					return CoronerDeathReason(controller);
				}
				catch (Exception)
				{
				}
			}
			CauseOfDeath causeOfDeath = controller.causeOfDeath;
			CauseOfDeath val = causeOfDeath;
			return (int)val switch
			{
				0 => "Uncertain circumstances", 
				9 => "Drowned", 
				4 => "Strangulated", 
				5 => "Suffocation", 
				6 => "Mauling", 
				3 => "Blast", 
				8 => "Crushed", 
				11 => "Electrocuted", 
				2 => "Gravity", 
				7 => "Gunshots", 
				12 => "Kicked", 
				_ => "Uncertain circumstances", 
			};
		}

		private static string CoronerDeathReason(PlayerControllerB controller)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return AdvancedDeathTracker.StringifyCauseOfDeath((AdvancedCauseOfDeath?)AdvancedDeathTracker.GetCauseOfDeath(controller));
		}

		public static void Open()
		{
			try
			{
				Transform transform = ((Component)HUDManager.Instance.endgameStatsAnimator).gameObject.transform;
				for (int i = 0; i < transform.childCount; i++)
				{
					Transform child = transform.GetChild(i);
					if (((Object)child).name == "Text")
					{
						((Component)child).gameObject.SetActive(false);
					}
					if (((Object)child).name == "BGBoxes" || ((Object)child).name == "Lines")
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
				bool active = false;
				int childCount = PlayerNoteContainer.childCount;
				for (int num = childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)PlayerNoteContainer.GetChild(num)).gameObject);
				}
				childCount = DeadNoteContainer.childCount;
				for (int num2 = childCount - 1; num2 >= 0; num2--)
				{
					Object.Destroy((Object)(object)((Component)DeadNoteContainer.GetChild(num2)).gameObject);
				}
				childCount = MissingNoteContainer.childCount;
				for (int num3 = childCount - 1; num3 >= 0; num3--)
				{
					Object.Destroy((Object)(object)((Component)MissingNoteContainer.GetChild(num3)).gameObject);
				}
				for (int j = 0; j < StartOfRound.Instance.allPlayerScripts.Length; j++)
				{
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[j];
					if (val.disconnectedMidGame)
					{
						continue;
					}
					string text = ((TMP_Text)HUDManager.Instance.statsUIElements.playerNamesText[j]).text;
					Texture2D avatar = PlayerControllerB.GetAvatar(val);
					string text2 = ((TMP_Text)HUDManager.Instance.statsUIElements.playerNotesText[j]).text;
					if (text2.StartsWith("Notes:"))
					{
						text2 = text2.Substring(6);
					}
					if (Chainloader.PluginInfos.ContainsKey("com.elitemastereric.coroner"))
					{
						int num4 = text2.IndexOf("Cause of Death");
						if (num4 > -1)
						{
							text2 = text2.Substring(0, num4);
						}
					}
					text2 = text2.Trim();
					string deathReason = GetDeathReason(val);
					if (text2 != "")
					{
						AddPlayerNote(avatar, text, text2);
					}
					if ((Object)(object)HUDManager.Instance.statsUIElements.playerStates[j].sprite == (Object)(object)HUDManager.Instance.statsUIElements.deceasedIcon)
					{
						AddDeceasedNote(avatar, text, deathReason);
					}
					if ((Object)(object)HUDManager.Instance.statsUIElements.playerStates[j].sprite == (Object)(object)HUDManager.Instance.statsUIElements.missingIcon)
					{
						active = true;
						AddMissingNote(avatar, text);
					}
				}
				((Component)MissingTitle).gameObject.SetActive(active);
				((Component)MissingScrollBox).gameObject.SetActive(active);
				CollectedScrap = RoundManager.Instance.scrapCollectedInLevel;
				TotalScrap = (int)RoundManager.Instance.totalScrapValueInLevel;
				AreAllDead = ((Behaviour)HUDManager.Instance.statsUIElements.allPlayersDeadOverlay).enabled;
				((Component)AllDead).gameObject.SetActive(AreAllDead);
				((TMP_Text)CollectedText).text = "";
				((TMP_Text)TotalText).text = "";
				((Component)CollectedText).gameObject.SetActive(true);
				((Component)TotalText).gameObject.SetActive(true);
				((Component)CollectedLine).gameObject.SetActive(true);
				((Component)CollectedLabel).gameObject.SetActive(true);
				((Component)ScrapLost).gameObject.SetActive(false);
				Grade = ((TMP_Text)HUDManager.Instance.statsUIElements.gradeLetter).text;
				((TMP_Text)GradeText).text = "";
				Container.SetActive(true);
				LayoutRebuilder.ForceRebuildLayoutImmediate(Container.GetComponent<RectTransform>());
				((MonoBehaviour)HUDManager.Instance).StartCoroutine(AnimateMenu());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error occured while opening end screen!");
				Plugin.Log.LogError((object)ex);
			}
		}

		private static IEnumerator AnimateMenu()
		{
			Cursor.lockState = (CursorLockMode)2;
			Cursor.visible = true;
			yield return (object)new WaitForSeconds(1f);
			float p = 0f;
			((TMP_Text)TotalText).text = TotalScrap.ToString() ?? "";
			while (p < 1f)
			{
				((TMP_Text)CollectedText).text = CollectedScrap.ToString() ?? "";
				p += 0.05f;
				yield return (object)new WaitForEndOfFrame();
			}
			if (AreAllDead)
			{
				yield return (object)new WaitForSeconds(1f);
				((Component)CollectedText).gameObject.SetActive(false);
				((Component)TotalText).gameObject.SetActive(false);
				((Component)CollectedLine).gameObject.SetActive(false);
				((Component)CollectedLabel).gameObject.SetActive(false);
				((TMP_Text)ScrapLostText).text = "Lost " + Mathf.Round((1f - Perks.GetMultiplier("SaveLoot")) * 1000f) / 10f + "% scrap";
				((Component)ScrapLost).gameObject.SetActive(true);
			}
			yield return (object)new WaitForSeconds(1f);
			((TMP_Text)GradeText).text = Grade;
			yield return (object)new WaitForSeconds(5.5f - (AreAllDead ? 1f : 0f));
			Container.SetActive(false);
			Cursor.lockState = (CursorLockMode)1;
			Cursor.visible = false;
		}

		public static Texture2D GetTextureFromImage(Image? image)
		{
			//IL_0012: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (image.HasValue)
			{
				Texture2D val = new Texture2D((int)image.Value.Width, (int)image.Value.Height);
				for (int i = 0; i < image.Value.Width; i++)
				{
					for (int j = 0; j < image.Value.Height; j++)
					{
						Image value = image.Value;
						Color pixel = ((Image)(ref value)).GetPixel(i, j);
						val.SetPixel(i, (int)image.Value.Height - j, new Color((float)(int)pixel.r / 255f, (float)(int)pixel.g / 255f, (float)(int)pixel.b / 255f, (float)(int)pixel.a / 255f));
					}
				}
				val.Apply();
				return val;
			}
			return null;
		}

		private static void AddPlayerNote(Texture2D image, string username, string notes)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(NoteContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			((TMP_Text)((Component)val.transform.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = notes;
			val.transform.parent = PlayerNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		private static void AddDeceasedNote(Texture2D image, string username, string deathReason)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(DeadContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			((TMP_Text)((Component)val.transform.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = deathReason;
			val.transform.parent = DeadNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		private static void AddMissingNote(Texture2D image, string username)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(MissingContainerPrefab, PlayerNoteContainer);
			Transform child = val.transform.GetChild(0);
			Transform child2 = child.GetChild(0);
			if ((Object)(object)image != (Object)null)
			{
				((Component)child2).GetComponent<RawImage>().texture = (Texture)(object)image;
			}
			else
			{
				((Component)child2).gameObject.SetActive(false);
			}
			((TMP_Text)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).text = username;
			val.transform.parent = MissingNoteContainer;
			val.transform.localScale = new Vector3(1f, 1f, 1f);
		}

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPostfix]
		public static void Attach(HUDManager __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			Container = Object.Instantiate<GameObject>(PerformanceReportPrefab, ((Component)__instance.endgameStatsAnimator).transform.parent);
			Container.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
			Container.GetComponent<RectTransform>().sizeDelta = new Vector2(823f, 717f);
			Transform child = Container.transform.GetChild(1);
			Transform child2 = child.GetChild(0);
			Transform child3 = child.GetChild(1);
			Transform child4 = Container.transform.GetChild(2);
			AllDead = child2.GetChild(1);
			PlayerNoteContainer = child2.GetChild(2).GetChild(0).GetChild(0);
			DeadNoteContainer = child3.GetChild(1).GetChild(0).GetChild(0);
			MissingTitle = child3.GetChild(2);
			MissingScrollBox = child3.GetChild(3);
			MissingNoteContainer = MissingScrollBox.GetChild(0).GetChild(0);
			Transform child5 = child4.GetChild(0);
			CollectedLabel = child5.GetChild(0);
			CollectedText = ((Component)child5.GetChild(1)).GetComponent<TextMeshProUGUI>();
			CollectedLine = child5.GetChild(2);
			TotalText = ((Component)child5.GetChild(3)).GetComponent<TextMeshProUGUI>();
			ScrapLost = child5.GetChild(4);
			ScrapLostText = ((Component)ScrapLost.GetChild(0)).GetComponent<TextMeshProUGUI>();
			GradeText = ((Component)child4.GetChild(1).GetChild(1)).GetComponent<TextMeshProUGUI>();
			Container.SetActive(false);
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchHUDManagerEndOfGame(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->EndOfGame...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldstr && list[i].operand.ToString() == "displayStats")
				{
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)OpenEndgameMenuMethod));
					i++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched StartOfRound->EndOfGame!");
			return list.AsEnumerable();
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	public class LobbySetup
	{
		private static GameObject LobbyScreenPrefab;

		private static MenuManager MenuManagerInstance;

		private static GameObject LobbyScreen;

		private static LobbySettings Settings;

		public static void LoadAssets(AssetBundle assets)
		{
			LobbyScreenPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/LobbyScreen.prefab");
		}

		[HarmonyPatch(typeof(MenuManager), "Start")]
		[HarmonyPrefix]
		public static void Initialize(MenuManager __instance)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = __instance.menuButtons.GetComponentInParent<Canvas>();
			LobbyScreen = Object.Instantiate<GameObject>(LobbyScreenPrefab, ((Component)componentInParent).transform);
			LobbyScreen.transform.localScale = new Vector3(1f, 1f, 1f);
			Settings = LobbyScreen.GetComponent<LobbySettings>();
			LobbyScreen.SetActive(false);
			LobbySettings settings = Settings;
			settings.OnContinue = (BaseSettings<LobbyConfiguration>.Continue)Delegate.Combine(settings.OnContinue, (BaseSettings<LobbyConfiguration>.Continue)delegate(LobbyConfiguration configuration, string presetName)
			{
				ServerConfiguration.Instance.CopyFrom(configuration);
				ServerConfiguration.Instance.WasLoaded();
				try
				{
					ES3.Save<string>("preset", presetName, GameNetworkManager.Instance.currentSaveFileName);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while saving preset in game save file. Save file most likely corrupted?");
					Plugin.Log.LogError((object)ex);
				}
				StartHost();
			});
			LobbySettings settings2 = Settings;
			settings2.OnCancel = (BaseSettings<LobbyConfiguration>.Cancel)Delegate.Combine(settings2.OnCancel, (BaseSettings<LobbyConfiguration>.Cancel)delegate
			{
				if (!__instance.menuButtons.gameObject.activeSelf)
				{
					__instance.menuButtons.gameObject.SetActive(true);
				}
			});
		}

		[HarmonyPatch(typeof(MenuManager), "ConfirmHostButton")]
		[HarmonyPrefix]
		public static bool StartHosting(MenuManager __instance)
		{
			if (string.IsNullOrEmpty(__instance.lobbyNameInputField.text))
			{
				((TMP_Text)__instance.tipTextHostSettings).text = "Enter a lobby name!";
				return false;
			}
			__instance.HostSettingsScreen.SetActive(false);
			if (__instance.lobbyNameInputField.text.Length > 40)
			{
				__instance.lobbyNameInputField.text = __instance.lobbyNameInputField.text.Substring(0, 40);
			}
			ES3.Save<string>("HostSettings_Name", __instance.lobbyNameInputField.text, "LCGeneralSaveData");
			ES3.Save<bool>("HostSettings_Public", __instance.hostSettings_LobbyPublic, "LCGeneralSaveData");
			MenuManagerInstance = __instance;
			string text = "";
			text = ((ModpackConfig.Instance.SkipPresets.Value || !ES3.KeyExists("preset", GameNetworkManager.Instance.currentSaveFileName)) ? ModpackConfig.Instance.StandardPreset.Value : ES3.Load<string>("preset", GameNetworkManager.Instance.currentSaveFileName));
			LobbyConfigurationProvider.Instance = new LobbyConfigurationProvider();
			Settings.SetConfiguration(LobbyConfigurationProvider.Instance);
			if (text != "")
			{
				Settings.SelectPreset(text);
			}
			if (ModpackConfig.Instance.SkipPresets.Value)
			{
				StartHost();
			}
			else
			{
				LobbyScreen.SetActive(true);
			}
			return false;
		}

		public static void StartHost()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			LobbySizePatches.Handshake = null;
			LobbySizePatches.ConnectingClients = new Dictionary<ulong, Sync>();
			AdvancedCompany.Game.Player.Reset();
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(0);
			player.LoadLocal();
			player.LoadServer(GameNetworkManager.Instance.currentSaveFileName);
			player.EquipConfigurationCosmetics();
			ES3.Save<string>("preset", Settings.SelectedPreset.Name);
			AdvancedCompany.Network.Manager.Lobby = new Lobby
			{
				CurrentShip = Ship.Load(GameNetworkManager.Instance.currentSaveFileName),
				ConnectedPlayers = new Dictionary<int, AdvancedCompany.Game.Player> { { 0, player } }
			};
			GameNetworkManager.Instance.lobbyHostSettings = new HostSettings(MenuManagerInstance.lobbyNameInputField.text, MenuManagerInstance.hostSettings_LobbyPublic, "");
			GameNetworkManager.Instance.StartHost();
		}
	}
}
namespace AdvancedCompany.Terminal
{
	public class BoxedScreen : IScreen, ITextElement
	{
		public string Title;

		public List<ITextElement> Content;

		public virtual string GetText(int availableWidth)
		{
			string text = "  ╔" + new string('═', Title.Length + 2) + "╗\n╭─╢ <color=#ffffff>" + Title + "</color> ╟" + new string('─', availableWidth - 7 - Title.Length) + "╮\n│ ╚" + new string('═', Title.Length + 2) + "╝" + new string(' ', availableWidth - Title.Length - 7) + "│\n";
			foreach (ITextElement item in Content)
			{
				text += Utils.WrapText(item.GetText(availableWidth - 4), availableWidth, "│ ", " │");
			}
			return text + "╰" + new string('─', availableWidth - 2) + "╯\n";
		}
	}
	public class BoxedScreenStore : IScreen, ITextElement
	{
		public string Title;

		public int TotalCost = 0;

		public List<ITextElement> Content;

		public virtual string GetText(int availableWidth)
		{
			int groupCredits = AdvancedCompany.Game.Manager.Terminal.groupCredits;
			string text = "Credits: " + groupCredits;
			string text2 = "  ╔" + new string('═', Title.Length + 2) + "╗" + new string(' ', availableWidth - 6 - Title.Length - text.Length) + text + "\n╭─╢ <color=#ffffff>" + Title + "</color> ╟" + new string('─', availableWidth - 7 - Title.Length) + "╮\n│ ╚" + new string('═', Title.Length + 2) + "╝" + new string(' ', availableWidth - Title.Length - 7) + "│\n";
			foreach (ITextElement item in Content)
			{
				text2 += Utils.WrapText(item.GetText(availableWidth - 4), availableWidth, "│ ", " │");
			}
			int num = availableWidth - 11;
			int num2 = 6;
			string text3 = "$" + TotalCost;
			if (text3.Length < num2)
			{
				text3 = new string(' ', num2 - text3.Length) + text3;
			}
			text2 = text2 + "│" + new string(' ', num - 3) + "╔" + new string('═', num2 + 2) + "╗" + new string(' ', availableWidth - num - text3.Length - 3) + "│\n";
			text2 = text2 + "╰" + new string('─', num - 3) + "╢ " + ((groupCredits < TotalCost) ? "<color=#ff0000>" : "") + text3 + ((groupCredits < TotalCost) ? "</color>" : "") + " ╟" + new string('─', availableWidth - num - text3.Length - 3) + "╯\n";
			return text2 + new string(' ', num - 2) + "╚" + new string('═', num2 + 2) + "╝\n";
		}
	}
	public class BoxedScreenXP : IScreen, ITextElement
	{
		public string Title;

		public List<ITextElement> Content;

		public virtual string GetText(int availableWidth)
		{
			string text = "XP: " + AdvancedCompany.Network.Manager.Lobby.Player().RemainingXP + " Ship XP: " + AdvancedCompany.Network.Manager.Lobby.CurrentShip.RemainingXP;
			string text2 = "  ╔" + new string('═', Title.Length + 2) + "╗" + new string(' ', availableWidth - 6 - Title.Length - text.Length) + text + "\n╭─╢ <color=#ffffff>" + Title + "</color> ╟" + new string('─', availableWidth - 7 - Title.Length) + "╮\n│ ╚" + new string('═', Title.Length + 2) + "╝" + new string(' ', availableWidth - Title.Length - 7) + "│\n";
			foreach (ITextElement item in Content)
			{
				text2 += Utils.WrapText(item.GetText(availableWidth - 4), availableWidth, "│ ", " │");
			}
			return text2 + "╰" + new string('─', availableWidth - 2) + "╯\n";
		}
	}
	public class Command
	{
		public string CommandText;

		public string Description;

		public bool IsActive = true;

		public bool IsCheat = false;

		public bool ServerOnly = false;

		public Action<string[]> Action;

		internal static List<Command> Commands = new List<Command>();

		public Command()
		{
			Commands.Add(this);
		}

		public static Command FindCommand(string commandText, bool isServer)
		{
			for (int i = 0; i < Commands.Count; i++)
			{
				if (Commands[i].IsActive && Commands[i].CommandText.Equals(commandText, StringComparison.OrdinalIgnoreCase) && (!Commands[i].ServerOnly || isServer))
				{
					return Commands[i];
				}
			}
			return null;
		}

		public void Execute(string[] @params)
		{
			Action(@params);
		}
	}
	public class CursorElement : ITextElement
	{
		public string Name;

		public string Description;

		public Action Action;

		public virtual string GetText(int availableWidth)
		{
			string text = Name;
			if (Description != null && Description != "")
			{
				text = text + "\n" + Utils.WrapText(Description, availableWidth, "  ");
			}
			return text;
		}
	}
	public class CursorMenu : IScrollable, ITextElement
	{
		private int _SelectedElement;

		public List<ITextElement> Elements;

		private int _ScrollPosStart = 0;

		private int _ScrollPosEnd = 0;

		private int _LastScrollPos = 0;

		public int SelectedElement
		{
			get
			{
				return _SelectedElement;
			}
			set
			{
				int num = value - _SelectedElement;
				bool flag = num > 0;
				if (value >= Elements.Count)
				{
					_SelectedElement = 0;
				}
				else if (value < 0)
				{
					_SelectedElement = Elements.Count - 1;
				}
				else
				{
					_SelectedElement = value;
				}
				int selectedElement = _SelectedElement;
				while (!(Elements[_SelectedElement] is CursorElement))
				{
					_SelectedElement += (flag ? 1 : (-1));
					if (_SelectedElement == selectedElement)
					{
						break;
					}
					if (_SelectedElement >= Elements.Count)
					{
						_SelectedElement = 0;
					}
					else if (_SelectedElement < 0)
					{
						_SelectedElement = Elements.Count - 1;
					}
				}
			}
		}

		public void Execute()
		{
			(Elements[SelectedElement] as CursorElement).Action();
		}

		public virtual string GetText(int availableWidth)
		{
			string text = "";
			int num = 0;
			for (int i = 0; i < Elements.Count; i++)
			{
				if (Elements[i] is CursorElement)
				{
					if (_SelectedElement == i)
					{
						_ScrollPosStart = num;
					}
					string text2 = " " + ((_SelectedElement == i) ? "<focus>►" : " ") + " " + Utils.WrapText(Elements[i].GetText(availableWidth - 3), availableWidth, "   ", "", padLeftFirst: false);
					num += text2.Count((char c) => c.Equals('\n'));
					text += text2;
					if (_SelectedElement == i)
					{
						_ScrollPosEnd = num;
					}
				}
				else
				{
					string text3 = Elements[i].GetText(availableWidth) ?? "";
					num += text3.Count((char c) => c.Equals('\n'));
					text += text3;
				}
			}
			return text;
		}

		public int GetScroll(int maxHeight)
		{
			int lastScrollPos = _LastScrollPos;
			int num = _LastScrollPos + maxHeight;
			int num2 = _LastScrollPos;
			if (_ScrollPosEnd > num - 3)
			{
				num2 = _ScrollPosEnd + 3 - maxHeight;
			}
			if (_ScrollPosStart < lastScrollPos + 3)
			{
				num2 = _ScrollPosStart - 3;
			}
			if (num2 < 0)
			{
				num2 = 0;
			}
			_LastScrollPos = num2;
			return num2;
		}
	}
	public class HalfBoxedScreen : IScreen, ITextElement
	{
		public string Title;

		public int LeftWidth = 20;

		public int Height = 20;

		public List<ITextElement> RightContent;

		public List<ITextElement> LeftContent;

		public virtual string GetText(int availableWidth)
		{
			string text = "  ╔" + new string('═', Title.Length + 2) + "╗\n╭─╢ <color=#ffffff>" + Title + "</color> ╟" + new string('─', availableWidth - 7 - Title.Length) + "╮\n│ ╚" + new string('═', Title.Length + 2) + "╝" + new string(' ', availableWidth - Title.Length - 7) + "│\n├" + new string('─', LeftWidth) + "┬" + new string('─', availableWidth - LeftWidth - 3) + "┤\n";
			string text2 = "";
			foreach (ITextElement item in LeftContent)
			{
				text2 += item.GetText(LeftWidth);
			}
			string text3 = "";
			int num = availableWidth - LeftWidth - 5;
			foreach (ITextElement item2 in RightContent)
			{
				text3 += item2.GetText(num);
			}
			string[] array = Utils.WrapText(text2, LeftWidth).Split(new char[1] { '\n' }, StringSplitOptions.None);
			string[] array2 = Utils.WrapText(text3, num).Split(new char[1] { '\n' }, StringSplitOptions.None);
			for (int i = 0; i < Height - 5; i++)
			{
				string text4 = ((array.Length > i) ? array[i] : "");
				if (text4.Length < LeftWidth)
				{
					text4 += new string(' ', LeftWidth - text4.Length);
				}
				string text5 = ((array2.Length > i) ? array2[i] : "");
				text5 = text5.TrimEnd();
				if (text5.Length < num)
				{
					text5 += new string(' ', num - text5.Length);
				}
				text = text + "│" + text4 + "│ " + text5 + " │\n";
			}
			return text + "╰" + new string('─', availableWidth - 2) + "╯\n";
		}
	}
	internal interface IScreen : ITextElement
	{
	}
	public interface IScrollable : ITextElement
	{
		int GetScroll(int maxHeight);
	}
	internal class ItemCursorElement : CursorElement
	{
		internal Item Item;

		internal int Amount;

		public ItemCursorElement(Item item)
		{
			Item = item;
			Amount = 0;
		}

		public override string GetText(int availableWidth)
		{
			int itemPrice = AdvancedCompany.Game.Manager.Items.GetItemPrice(Item, discount: true);
			int itemSalesPercentage = AdvancedCompany.Game.Manager.Items.GetItemSalesPercentage(Item);
			int num = 22;
			int num2 = 6;
			string text = "<color=#ffffff>" + ((Item.itemName.Length > num) ? Item.itemName.Substring(0, num) : (Item.itemName + new string(' ', num - Item.itemName.Length))) + "</color>";
			string text2 = "$" + itemPrice;
			text2 = new string(' ', num2 - text2.Length) + text2;
			string text3 = Amount.ToString() ?? "";
			if (text3.Length == 1)
			{
				text3 = " " + text3;
			}
			string text4 = "← " + text3 + " → " + text + " " + text2;
			int num3 = 5;
			string text5 = "";
			text5 = ((itemSalesPercentage >= 100) ? " " : (" -" + (100 - itemSalesPercentage) + "%"));
			text4 = text4 + new string(' ', num3 - text5.Length) + text5;
			int num4 = 7;
			string text6 = " $" + Amount * itemPrice;
			return text4 + new string(' ', num4 - text6.Length) + text6;
		}
	}
	public interface ITextElement
	{
		string GetText(int availableWidth);
	}
	internal class PerkCursorElement : CursorElement
	{
		private Perk Perk;

		public PerkCursorElement(Perk perk)
		{
			Perk = perk;
		}

		public override string GetText(int availableWidth)
		{
			int num = 25;
			int num2 = 11;
			string text = ((Perk.Name.Length > num) ? Perk.Name.Substring(0, num) : (Perk.Name + new string(' ', num - Perk.Name.Length)));
			int num3 = 0;
			int num4 = 0;
			if (Perk.PerkType == Perk.Type.PLAYER)
			{
				num3 = AdvancedCompany.Network.Manager.Lobby.Player().GetLevel(Perk);
				num4 = Perk.GetNextPrice(AdvancedCompany.Network.Manager.Lobby.Player());
			}
			if (Perk.PerkType == Perk.Type.SHIP)
			{
				num3 = AdvancedCompany.Network.Manager.Lobby.CurrentShip.GetLevel(Perk);
				num4 = Perk.GetNextPrice(AdvancedCompany.Network.Manager.Lobby.CurrentShip);
			}
			int num5 = Perk.Levels - num3;
			if (num5 < 0)
			{
				num5 = 0;
			}
			int num6 = num2 - Perk.Levels;
			if (num6 < 0)
			{
				num6 = 0;
			}
			string text2 = new string('◼', num3) + new string('□', num5) + new string(' ', num6);
			string text3 = "";
			if (num4 > 0)
			{
				text3 = " " + num4 + "XP";
			}
			return text + text2 + text3;
		}
	}
	public class ScrollBox : ITextElement
	{
		public IScrollable Content;

		public int MaxHeight = 0;

		public int ScrollPos = 0;

		public ScrollBox(int maxHeight)
		{
			MaxHeight = maxHeight;
		}

		public string GetText(int availableWidth)
		{
			string text = Content.GetText(availableWidth);
			int num = text.Count((char c) => c.Equals('\n')) - 1;
			if (num > MaxHeight)
			{
				text = Content.GetText(availableWidth - 2);
				int num2 = Content.GetScroll(MaxHeight);
				string[] array = text.Split('\n');
				if (num2 >= array.Length - MaxHeight)
				{
					num2 = array.Length - MaxHeight - 1;
				}
				if (num2 < 0)
				{
					num2 = 0;
				}
				string text2 = "";
				int num3 = (int)System.Math.Floor((float)MaxHeight * ((float)MaxHeight / (float)array.Length));
				int num4 = (int)System.Math.Round((float)num2 / (float)(array.Length - MaxHeight) * (float)(MaxHeight - num3));
				for (int i = num2; i < num2 + MaxHeight && i < array.Length; i++)
				{
					bool flag = i - num2 >= num4 && i - num2 <= num4 + num3;
					string text3 = array[i];
					text2 = text2 + text3 + " " + (flag ? "█" : "░") + "\n";
				}
				return text2;
			}
			return text;
		}
	}
	public class TextElement : ITextElement
	{
		public string Text;

		public string GetText(int availableWidth)
		{
			return Utils.WrapText(Text, availableWidth);
		}

		public static explicit operator TextElement(string text)
		{
			return new TextElement
			{
				Text = text
			};
		}
	}
	internal class UnlockableCursorElement : CursorElement
	{
		internal UnlockableItem Item;

		internal int Amount;

		internal int MaxAmount = 1;

		public UnlockableCursorElement(UnlockableItem item, int maxAmount)
		{
			MaxAmount = maxAmount;
			Item = item;
			Amount = 0;
		}

		public override string GetText(int availableWidth)
		{
			int num = 22;
			int num2 = 6;
			string text = "<color=#ffffff>" + ((Item.unlockableName.Length > num) ? Item.unlockableName.Substring(0, num) : (Item.unlockableName + new string(' ', num - Item.unlockableName.Length))) + "</color>";
			int unlockablePrice = AdvancedCompany.Game.Manager.Items.GetUnlockablePrice(Item);
			string text2 = "$" + Mathf.FloorToInt((float)unlockablePrice);
			text2 = new string(' ', num2 - text2.Length) + text2;
			string text3 = Amount.ToString() ?? "";
			if (text3.Length == 1)
			{
				text3 = " " + text3;
			}
			string text4 = "← " + text3 + " → " + text + " " + text2;
			text4 += "     ";
			int num3 = 7;
			string text5 = " $" + Amount * unlockablePrice;
			return text4 + new string(' ', num3 - text5.Length) + text5;
		}
	}
	public class Utils
	{
		public static string WrapText(string text, int lineLength, string padLeft = "", string padRight = "", bool padLeftFirst = true)
		{
			bool flag = true;
			int num = 0;
			string text2 = "";
			string text3 = "";
			int num2 = 0;
			int num3 = -1;
			bool flag2 = false;
			for (int i = 0; i < text.Length; i++)
			{
				num = lineLength - padRight.Length - padLeft.Length;
				char c = text[i];
				if (c == ' ')
				{
					num3 = text3.Length;
				}
				if (c == '<')
				{
					flag2 = true;
				}
				if (c != '\n')
				{
					text3 += c;
				}
				if (!flag2 && c != '\n')
				{
					num2++;
				}
				if (c == '>' && flag2)
				{
					flag2 = false;
				}
				if (num2 <= num && c != '\n')
				{
					continue;
				}
				string text4 = ((padLeftFirst || !flag) ? padLeft : "");
				if (c != ' ' && c != '\n')
				{
					if (num3 == -1)
					{
						string text5 = text4 + text3 + padRight;
						text2 = text2 + text5 + "\n";
						text3 = "";
						num2 = 0;
					}
					else
					{
						string text6 = text4 + text3.Substring(0, num3) + new string(' ', System.Math.Max(0, num - num3)) + padRight;
						text2 = text2 + text6 + "\n";
						text3 = text3.Substring(num3 + 1);
						num2 = text3.Length;
					}
					num3 = -1;
					flag = false;
					continue;
				}
				if (text3 != "")
				{
					text2 = text2 + text4 + text3 + new string(' ', System.Math.Max(0, num - num2)) + padRight + "\n";
				}
				text3 = "";
				num2 = 0;
				num3 = -1;
				flag = false;
			}
			if (text3 != "")
			{
				text2 = text2 + ((padLeftFirst || !flag) ? padLeft : "") + text3 + new string(' ', System.Math.Max(0, num - num2)) + padRight + "\n";
			}
			return text2;
		}
	}
}
namespace AdvancedCompany.Terminal.Applications
{
	[Bootable]
	internal class BuyApplication : IApplication, IFallbackApplication
	{
		private MobileTerminal Terminal;

		private IScreen CurrentScreen;

		private CursorMenu CurrentCursorMenu;

		public static void Boot()
		{
			BuyApplication application = new BuyApplication();
			MobileTerminal.RegisterApplication("buy", application);
		}

		public void Exit()
		{
		}

		internal void Buy(UnlockableItem item, int amount)
		{
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			int num = 0;
			int num2 = StartOfRound.Instance.unlockablesList.unlockables.IndexOf(item);
			if (num2 > -1)
			{
				num = amount * AdvancedCompany.Game.Manager.Items.GetUnlockablePrice(item);
				for (int i = 0; i < amount; i++)
				{
					list2.Add(num2);
				}
				int groupCredits = AdvancedCompany.Game.Manager.Terminal.groupCredits;
				if (groupCredits >= num)
				{
					AdvancedCompany.Network.Manager.Send(new BuyItems
					{
						Items = list.ToArray(),
						Unlockables = list2.ToArray(),
						NewCredits = groupCredits - num
					}, 0uL);
					Terminal.Exit();
					Terminal.Clear();
					Terminal.WriteLine("Thanks for your purchase! Your ordered items are on the way!");
				}
			}
		}

		internal void Buy(Item item, int amount)
		{
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			int num = 0;
			int num2 = -1;
			for (int i = 0; i < AdvancedCompany.Game.Manager.Terminal.buyableItemsList.Length; i++)
			{
				if ((Object)(object)AdvancedCompany.Game.Manager.Terminal.buyableItemsList[i] == (Object)(object)item)
				{
					num2 = i;
					break;
				}
			}
			if (num2 > -1)
			{
				num = amount * AdvancedCompany.Game.Manager.Items.GetItemPrice(item, discount: true);
				for (int j = 0; j < amount; j++)
				{
					list.Add(num2);
				}
				int groupCredits = AdvancedCompany.Game.Manager.Terminal.groupCredits;
				if (groupCredits >= num)
				{
					AdvancedCompany.Network.Manager.Send(new BuyItems
					{
						Items = list.ToArray(),
						Unlockables = list2.ToArray(),
						NewCredits = groupCredits - num
					}, 0uL);
					Terminal.Exit();
					Terminal.Clear();
					Terminal.WriteLine("Thanks for your purchase! Your ordered items are on the way!");
				}
			}
		}

		public void Fallback(MobileTerminal terminal, string input)
		{
			string[] array = input.Split(" ");
			string text = "";
			int num = 1;
			for (int i = 0; i < array.Length; i++)
			{
				if (int.TryParse(array[i], out var result))
				{
					num = result;
				}
				else
				{
					text += array[i];
				}
			}
			Main(terminal, new string[2]
			{
				text,
				num.ToString() ?? ""
			});
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			if (!AdvancedCompany.Network.Manager.Lobby.Player().Controller.isInHangarShipRoom)
			{
				terminal.WriteLine("You can't buy items outside of the ship.");
				terminal.Exit();
				return;
			}
			Terminal = terminal;
			int amount = 1;
			string text = "";
			for (int i = 0; i < args.Length; i++)
			{
				if (int.TryParse(args[i], out var result))
				{
					amount = result;
				}
				else
				{
					text += args[i];
				}
			}
			(float, object) tuple = FindLowest(text);
			if (tuple.Item2 != null)
			{
				object item2 = tuple.Item2;
				Item item = (Item)((item2 is Item) ? item2 : null);
				if (item != null)
				{
					int num = AdvancedCompany.Game.Manager.Items.GetItemPrice(item) * amount;
					if (num <= AdvancedCompany.Game.Manager.Terminal.groupCredits)
					{
						CurrentCursorMenu = new CursorMenu
						{
							Elements = new List<ITextElement>
							{
								new CursorElement
								{
									Name = "CONFIRM",
									Action = delegate
									{
										Buy(item, amount);
									}
								},
								new CursorElement
								{
									Name = "DENY",
									Action = delegate
									{
										Terminal.Clear();
										Terminal.Exit();
									}
								}
							}
						};
						CurrentScreen = new BoxedScreenStore
						{
							Title = "BUY",
							TotalCost = num,
							Content = new List<ITextElement>
							{
								new TextElement
								{
									Text = $"Do you want to buy {amount}x {item.itemName} for a total cost of {num} credits?"
								},
								CurrentCursorMenu
							}
						};
					}
					else
					{
						CurrentCursorMenu = new CursorMenu
						{
							Elements = new List<ITextElement>
							{
								new CursorElement
								{
									Name = "BACK",
									Action = delegate
									{
										Terminal.Clear();
										Terminal.Exit();
									}
								}
							}
						};
						CurrentScreen = new BoxedScreenStore
						{
							Title = "BUY",
							TotalCost = num,
							Content = new List<ITextElement>
							{
								new TextElement
								{
									Text = $"You can't afford {amount}x {item.itemName}. You need at least {num} credits!"
								},
								CurrentCursorMenu
							}
						};
					}
					Terminal.DeactivateInput();
					return;
				}
				item2 = tuple.Item2;
				UnlockableItem unlockableItem = (UnlockableItem)((item2 is UnlockableItem) ? item2 : null);
				if (unlockableItem == null)
				{
					return;
				}
				int num2 = unlockableItem.maxNumber - ((unlockableItem.alreadyUnlocked || unlockableItem.hasBeenUnlockedByPlayer) ? 1 : 0);
				if (num2 > 1)
				{
					if (amount > num2)
					{
						amount = num2;
					}
					int num3 = AdvancedCompany.Game.Manager.Items.GetUnlockablePrice(unlockableItem) * amount;
					if (num3 <= AdvancedCompany.Game.Manager.Terminal.groupCredits)
					{
						CurrentCursorMenu = new CursorMenu
						{
							Elements = new List<ITextElement>
							{
								new CursorElement
								{
									Name = "CONFIRM",
									Action = delegate
									{
										Buy(unlockableItem, amount);
									}
								},
								new CursorElement
								{
									Name = "DENY",
									Action = delegate
									{
										Terminal.Clear();
										Terminal.Exit();
									}
								}
							}
						};
						CurrentScreen = new BoxedScreenStore
						{
							Title = "BUY",
							TotalCost = num3,
							Content = new List<ITextElement>
							{
								new TextElement
								{
									Text = $"Do you want to buy {amount}x {unlockableItem.unlockableName} for a total cost of {num3} credits?"
								},
								CurrentCursorMenu
							}
						};
					}
					else
					{
						CurrentCursorMenu = new CursorMenu
						{
							Elements = new List<ITextElement>
							{
								new CursorElement
								{
									Name = "BACK",
									Action = delegate
									{
										Terminal.Clear();
										Terminal.Exit();
									}
								}
							}
						};
						CurrentScreen = new BoxedScreenStore
						{
							Title = "BUY",
							TotalCost = num3,
							Content = new List<ITextElement>
							{
								new TextElement
								{
									Text = $"You can't afford {amount}x {unlockableItem.unlockableName}. You need at least {num3} credits!"
								},
								CurrentCursorMenu
							}
						};
					}
					Terminal.DeactivateInput();
				}
				else
				{
					terminal.WriteLine(unlockableItem.unlockableName + " was already bought!");
					terminal.Exit();
				}
			}
			else
			{
				terminal.WriteLine("Couldn't find item.");
				terminal.Exit();
			}
		}

		public void Submit(string text)
		{
		}

		internal (float, object) FindLowest(string input)
		{
			input = input.Replace(" ", "").Replace("-", "").ToLowerInvariant()
				.Trim();
			List<(string, object)> list = new List<(string, object)>();
			for (int i = 0; i < AdvancedCompany.Game.Manager.Items.BuyableItems.Count; i++)
			{
				Item val = AdvancedCompany.Game.Manager.Items.BuyableItems[i];
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(val.itemName);
				if (byItemName == null || byItemName.Active)
				{
					string item = val.itemName.Replace(" ", "").Replace("-", "").ToLowerInvariant();
					list.Add((item, val));
				}
			}
			for (int j = 0; j < AdvancedCompany.Game.Manager.Items.ShipUpgrades.Count; j++)
			{
				UnlockableItem val2 = AdvancedCompany.Game.Manager.Items.ShipUpgrades[j];
				string item2 = val2.unlockableName.Replace(" ", "").Replace("-", "").ToLowerInvariant();
				list.Add((item2, val2));
			}
			for (int k = 0; k < AdvancedCompany.Game.Manager.Items.Decorations.Count; k++)
			{
				UnlockableItem val3 = AdvancedCompany.Game.Manager.Items.Decorations[k];
				string item3 = val3.unlockableName.Replace(" ", "").Replace("-", "").ToLowerInvariant();
				list.Add((item3, val3));
			}
			float num = 1000f;
			object obj = null;
			foreach (var item4 in list)
			{
				int num2 = Distance(input, item4.Item1);
				if (input.Length >= 3 && item4.Item1.StartsWith(input))
				{
					num2 = 1;
				}
				if (item4.Item1 == input)
				{
					num2 = 0;
				}
				if (num2 < 10 && ((float)num2 < num || obj == null))
				{
					num = num2;
					obj = item4.Item2;
				}
			}
			return (num, obj);
		}

		public float Certainty(string input)
		{
			if (!AdvancedCompany.Network.Manager.Lobby.Player().Controller.isInHangarShipRoom)
			{
				return 0f;
			}
			string[] array = input.Split(" ");
			string text = "";
			for (int i = 0; i < array.Length; i++)
			{
				if (!int.TryParse(array[i], out var _))
				{
					text += array[i];
				}
			}
			(float, object) tuple = FindLowest(text);
			if (tuple.Item2 == null)
			{
				return 0f;
			}
			return Mathf.Clamp01(1f - tuple.Item1 / 10f);
		}

		public static int Distance(string source1, string source2)
		{
			int length = source1.Length;
			int length2 = source2.Length;
			int[,] array = new int[length + 1, length2 + 1];
			if (length == 0)
			{
				return length2;
			}
			if (length2 == 0)
			{
				return length;
			}
			int num = 0;
			while (num <= length)
			{
				array[num, 0] = num++;
			}
			int num2 = 0;
			while (num2 <= length2)
			{
				array[0, num2] = num2++;
			}
			for (int i = 1; i <= length; i++)
			{
				for (int j = 1; j <= length2; j++)
				{
					int num3 = ((source2[j - 1] != source1[i - 1]) ? 1 : 0);
					array[i, j] = System.Math.Min(System.Math.Min(array[i - 1, j] + 1, array[i, j - 1] + 1), array[i - 1, j - 1] + num3);
				}
			}
			return array[length, length2];
		}

		public void Update()
		{
			if (CurrentScreen == null)
			{
				return;
			}
			Terminal.SetText(CurrentScreen.GetText(58));
			if (CurrentCursorMenu != null)
			{
				if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement--;
				}
				if (((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement++;
				}
				if (((ButtonControl)Keyboard.current.enterKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.Execute();
				}
			}
		}
	}
	[Bootable]
	internal class CreditsApplication : IApplication
	{
		public static void Boot()
		{
			MobileTerminal.RegisterApplication("credits", new CreditsApplication());
		}

		public void Exit()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			int result;
			if (!NetworkManager.Singleton.IsServer)
			{
				terminal.WriteLine("Only host is allowed to run this command!");
			}
			else if (args.Length != 0 && int.TryParse(args[0], out result))
			{
				Terminal terminal2 = AdvancedCompany.Game.Manager.Terminal;
				terminal2.groupCredits += result;
				AdvancedCompany.Game.Manager.Terminal.SyncGroupCreditsServerRpc(AdvancedCompany.Game.Manager.Terminal.groupCredits, AdvancedCompany.Game.Manager.Terminal.numberOfItemsInDropship);
				terminal.WriteLine("You've been given " + result + " credits!");
			}
			else
			{
				terminal.WriteLine("Usage: credits [amount]");
			}
			terminal.Exit();
		}

		public void Submit(string text)
		{
		}

		public void Update()
		{
		}
	}
	[Bootable]
	public class DebugApplication : IApplication
	{
		public static void Boot()
		{
			DebugApplication application = new DebugApplication();
			MobileTerminal.RegisterApplication("debug", application);
		}

		public void Exit()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			if (args.Length != 0 && args[0] == "hack")
			{
				string text = "1db3 d306 1bbe 4424 4d39 cb8d 4acb 15a3\r\nd731 46f6 5c24 3cd2 f8dc 58d1 202e e524\r\nd514 6469 65b1 eed3 204d 73e2 82eb 81c0\r\ncd89 e7ba 515a 7365 7276 656b db64 68df\r\n65cd 8a5d 7a4c d01e 05e6 9810 980e aaf0\r\nc31d 62c9 87c0 55c2 59b1 b3d4 c283 b8be\r\na59a 2461 9b24 9b42 1fb7 6f62 6579 5f63\r\neadd b66b 66eb 06e9 1e33 18be 4786 2158\r\n5837 30dd 2ca4 dbbc 2db1 7fa5 b571 0594\r\nc01c a935 bbfb e0eb 38fd 8517 2ccf 811b\r\n223d 9264 6965 4b16 fca3 8bcb 5ee7 f70e\r\n1e94 5e60 d0f6 ea2a 8bd3 ed90 6469 6565";
				terminal.SetText(text);
			}
			else
			{
				if (args.Length != 0 && args[0] == "quota")
				{
					TimeOfDay instance = TimeOfDay.Instance;
					instance.quotaFulfilled += 100000;
				}
				string text2 = "╢ PLAYER STATUS ╟\n";
				text2 = text2 + "Local client ID: " + Lobby.LocalPlayerNum;
				AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player();
				text2 += ((player == null) ? "Local player not found in lobby?\n" : "Local player found in lobby!\n");
				if (player != null)
				{
					text2 = text2 + "Client ID:" + player.PlayerNum + "\n";
				}
				AdvancedCompany.Game.Player player2 = AdvancedCompany.Game.Player.GetPlayer(StartOfRound.Instance.localPlayerController);
				text2 += ((player2 == null) ? "Local player not found in players?\n" : "Local player found in players!\n");
				if (player2 != null)
				{
					text2 = text2 + "Client ID:" + player2.PlayerNum + "\n";
				}
				text2 += "\n";
				text2 += "╢ LOBBY STATUS ╟\n";
				text2 = text2 + "Game has started: " + GameNetworkManager.Instance.gameHasStarted + "\n";
				text2 = text2 + "Is in ship phase: " + StartOfRound.Instance.inShipPhase + "\n";
				text2 += "\n";
				text2 = text2 + "Clients: " + AdvancedCompany.Network.Manager.Lobby.ConnectedPlayers.Count + "\n";
				foreach (KeyValuePair<int, AdvancedCompany.Game.Player> connectedPlayer in AdvancedCompany.Network.Manager.Lobby.ConnectedPlayers)
				{
					List<string> list = new List<string>();
					foreach (KeyValuePair<string, int> level in connectedPlayer.Value.Levels)
					{
						list.Add(level.Key + "=" + level.Value);
					}
					text2 = text2 + "Client #" + connectedPlayer.Key + ": id=" + connectedPlayer.Value.PlayerNum + ";isLate=" + AdvancedCompany.Network.Manager.Lobby.LateJoiners.Contains(connectedPlayer.Key) + ";isDead=" + connectedPlayer.Value.Controller.isPlayerDead + ";cosmetic=" + string.Join(",", connectedPlayer.Value.Cosmetics) + ";xp=" + connectedPlayer.Value.XP + ";" + string.Join(";", list) + "\n";
				}
				terminal.SetText(text2);
			}
			terminal.Exit();
		}

		public void Submit(string text)
		{
		}

		public void Update()
		{
		}
	}
	[Bootable]
	public class ExtendDeadlineApplication : IApplication
	{
		private MobileTerminal Terminal;

		private IScreen CurrentScreen;

		private CursorMenu CurrentCursorMenu;

		public static void Boot()
		{
			MobileTerminal.RegisterApplication("extend", new ExtendDeadlineApplication());
		}

		public void Open()
		{
			string text = "";
			bool flag = false;
			int extendDeadlinePrice = Perks.ExtendDeadlinePrice;
			if (AdvancedCompany.Network.Manager.Lobby.CurrentShip.ExtendedDeadline)
			{
				text = "The deadline was already extended during this quota.";
			}
			else if (extendDeadlinePrice > AdvancedCompany.Game.Manager.Terminal.groupCredits)
			{
				text = "Insufficient funds.";
			}
			else
			{
				flag = true;
				text = "Do you really want to extend the deadline?";
			}
			List<ITextElement> list = new List<ITextElement>();
			if (flag)
			{
				list.Add(new CursorElement
				{
					Name = "CONFIRM",
					Action = delegate
					{
						Perks.ExtendDeadline();
						Terminal.Clear();
						Terminal.WriteLine("[ Deadline was extended by one day ]");
						Terminal.Exit();
					}
				});
				list.Add(new CursorElement
				{
					Name = "DENY",
					Action = delegate
					{
						Terminal.Clear();
						Terminal.Exit();
						Terminal.Submit("help");
					}
				});
			}
			else
			{
				list.Add(new CursorElement
				{
					Name = "BACK",
					Action = delegate
					{
						Terminal.Clear();
						Terminal.Exit();
						Terminal.Submit("help");
					}
				});
			}
			CursorMenu cursorMenu = new CursorMenu
			{
				Elements = list
			};
			BoxedScreen box = new BoxedScreen
			{
				Title = "EXTEND DEADLINE",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = $"To extend the deadline you need {extendDeadlinePrice} credits."
					},
					new TextElement
					{
						Text = " "
					},
					new TextElement
					{
						Text = text
					},
					cursorMenu
				}
			};
			SwitchTo(box, cursorMenu, back: false);
		}

		public void SwitchTo(BoxedScreen box, CursorMenu menu, bool back = true)
		{
			CurrentScreen = box;
			CurrentCursorMenu = menu;
			if (!back)
			{
				menu.SelectedElement = 0;
			}
		}

		public static void Close()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			if (!ServerConfiguration.Instance.General.EnableExtendDeadline)
			{
				Terminal.WriteLine("This command is not supported.");
				Terminal.Exit();
			}
			else
			{
				Terminal = terminal;
				Terminal.DeactivateInput();
				Open();
			}
		}

		public void Update()
		{
			Terminal.SetText(CurrentScreen.GetText(58));
			if (CurrentCursorMenu != null)
			{
				if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement--;
				}
				if (((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement++;
				}
				if (((ButtonControl)Keyboard.current.enterKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.Execute();
				}
			}
		}

		public void Exit()
		{
		}

		public void Submit(string text)
		{
		}
	}
	public class HelpApplication : IApplication
	{
		public void Exit()
		{
		}

		private string Headline()
		{
			float num = Random.Range(0f, 10000f);
			if (num > 9999f)
			{
				return "   mankind die   ";
			}
			if (num > 9998f)
			{
				return "  mankind serve  ";
			}
			if (num > 9997f)
			{
				return "   mankind obey  ";
			}
			return "advancing mankind";
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			terminal.SetText("                      ╔═════════════╗\r\n╭─────────────────────╢ <color=#ff6666>ADVANCED</color> <color=#ffffff>OS</color> ╟────────────────────╮\r\n│                     ╚═════════════╝                    │\r\n│                    " + Headline() + "                   │\r\n│                                                        │\r\n│ Welcome Lethal-1,                                      │\r\n│ Your <color=#ffffff>license</color> is <color=#00ff00>valid</color> for <color=#ffffff>2 years and 11 months</color>        │\r\n│                                                        │\r\n│ <color=#ffffff>▶ PERKS</color>                                                │\r\n│   Let you level your perks on-the-fly                  │\r\n" + (ServerConfiguration.Instance.General.EnableExtendDeadline ? "│ <color=#ffffff>▶ EXTEND</color>                                               │\r\n│   Extend the deadline.                                 │\r\n" : "") + "│ <color=#ffffff>▶ INFO</color>                                                 │\r\n│   Opens a manual with further information.             │\r\n│ <color=#ffffff>▶ STORE</color>                                                │\r\n│   Open the store.                                      │\r\n│ <color=#ffffff>▶ HELP</color>                                                 │\r\n│   Shows this text for guidance.                        │\r\n╰────────────────────────────────────────────────────────╯\r\n");
			terminal.Exit();
		}

		public void Submit(string text)
		{
		}

		public void Update()
		{
		}
	}
	public interface IApplication
	{
		void Main(MobileTerminal terminal, string[] args);

		void Exit();

		void Submit(string text);

		void Update();
	}
	internal interface IFallbackApplication
	{
		float Certainty(string input);

		void Fallback(MobileTerminal terminal, string input);
	}
	[Bootable]
	public class InfoApplication : IApplication
	{
		private MobileTerminal Terminal;

		private IScreen CurrentScreen;

		private CursorMenu CurrentCursorMenu;

		private TextElement Text;

		private Dictionary<string, string> HelpTexts = new Dictionary<string, string>
		{
			{ "Bulletproof vest", "This bulletproof vest with 100% certified organic kevlar is capable to withstand great amounts of mechanical impact. It will prove itself to be a valuable asset on your journeys through dangerous places. Can withstand all common turret shots and even shotgun shells." },
			{ "Cursed items", "These items are of particular interest to AdvancedTech. BUT BEWARE!: These items are extremely cursed and might alter the way you perceive reality in VERY harmful ways." },
			{ "Flippers", "Standing in front of a river but you are packed like a mule? These flippers with our proprietary coating (patented by AdvancedTech) helps you to swim even when your bags are filled. Oxygen not included." },
			{ "Headset", "Communication is key to the success of your mission. AdvancedTech provides you with the best of the best in communication hardware. The standard key for communication is 'V'." },
			{ "Helmet lamp", "Do you often find yourself in dark places? We do too. That's why we have invented this stylish helmet lamp for night dwellers. Put it onto your patented head equipment slot and press 'F' to toggle it on." },
			{ "Lightning rod", "Ever wondered what all that scrap you bring back to Lethal Company is used for? Here is your answer. Put it outside of your ship on an elevated place and deploy it by left clicking while holding it. AdvancedTech is not liable for any damages occuring due to misuse." },
			{ "Missile launcher", "Nothing is better than a nice evening firework. Fireworks are something which can invoke wonder in a wide range of species including humans. Please don't use fireworks on humans. AdvancedTech is not liable for any damages." },
			{ "Rocket boots", "Those pesky jars on the top of the shelf are bugging you too? No more we say! With the latest invention in personal rocket propellant devices by AdvancedTech you will reach not only the top of the shelf but the top of your building as well." },
			{ "Tactical helmet", "Looking for that little bit extra? Communications and light? We got you covered! This tactical helmet isn't only a fashion statement but also very useful when exploring big and dark places as well." },
			{ "Vision enhancer", "Lights not gonna cut it for you? This vision enhancer wont just make you see in the dark. You will see further in weather conditions like snow or fog and even water steam can't block your vision." }
		};

		public static void Boot()
		{
			MobileTerminal.RegisterApplication("info", new InfoApplication());
		}

		public void Open()
		{
			List<ITextElement> list = new List<ITextElement>();
			list.Add(new CursorElement
			{
				Name = "Bulletproof vest",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Cursed items",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Flippers",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Headset",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Helmet lamp",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Lightning rod",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Missile launcher",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Rocket boots",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Tactical helmet",
				Action = delegate
				{
				}
			});
			list.Add(new CursorElement
			{
				Name = "Vision enhancer",
				Action = delegate
				{
				}
			});
			list.Add(new TextElement
			{
				Text = " "
			});
			list.Add(new CursorElement
			{
				Name = "CLOSE",
				Action = delegate
				{
					Terminal.Clear();
					Terminal.Exit();
					Terminal.Submit("help");
				}
			});
			CursorMenu cursorMenu = new CursorMenu
			{
				Elements = list
			};
			Text = new TextElement();
			HalfBoxedScreen box = new HalfBoxedScreen
			{
				Title = "ENCYCLOPEDIA",
				LeftContent = new List<ITextElement> { cursorMenu },
				RightContent = new List<ITextElement> { Text }
			};
			SwitchTo(box, cursorMenu, back: false);
		}

		public void SwitchTo(HalfBoxedScreen box, CursorMenu menu, bool back = true)
		{
			CurrentScreen = box;
			CurrentCursorMenu = menu;
			if (!back)
			{
				menu.SelectedElement = 0;
			}
		}

		public static void Close()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			Terminal = terminal;
			Terminal.DeactivateInput();
			Open();
		}

		public void Update()
		{
			if (CurrentCursorMenu != null && CurrentCursorMenu.Elements[CurrentCursorMenu.SelectedElement] is CursorElement cursorElement && HelpTexts.ContainsKey(cursorElement.Name))
			{
				Text.Text = HelpTexts[cursorElement.Name];
			}
			Terminal.SetText(CurrentScreen.GetText(58));
			if (CurrentCursorMenu != null)
			{
				if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement--;
				}
				if (((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement++;
				}
				if (((ButtonControl)Keyboard.current.enterKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.Execute();
				}
			}
		}

		public void Exit()
		{
		}

		public void Submit(string text)
		{
		}
	}
	[Bootable]
	internal class PerksApplication : IApplication
	{
		private MobileTerminal Terminal;

		private IScreen CurrentScreen;

		private CursorMenu CurrentCursorMenu;

		private static BoxedScreenXP MainMenu;

		private static BoxedScreenXP RespecMenu;

		private static BoxedScreenXP PlayerPerksMenu;

		private static BoxedScreenXP ShipPerksMenu;

		private static BoxedScreenXP BuyPerkMenu;

		private static CursorMenu MainMenuCursorMenu;

		private static CursorMenu RespecCursorMenu;

		private static CursorMenu PlayerPerksCursorMenu;

		private static CursorMenu ShipPerksCursorMenu;

		private static CursorMenu BuyPerkCursorMenu;

		internal bool CanRespecPlayer => StartOfRound.Instance.localPlayerController.isInHangarShipRoom;

		internal bool CanRespecShip => (Object)(object)RoundManager.Instance.currentLevel != (Object)null && !RoundManager.Instance.currentLevel.spawnEnemiesAndScrap && !StartOfRound.Instance.inShipPhase;

		public static void Boot()
		{
			MobileTerminal.RegisterApplication("perks", new PerksApplication());
		}

		public void Init()
		{
			MainMenuCursorMenu = new CursorMenu
			{
				Elements = new List<ITextElement>
				{
					new CursorElement
					{
						Name = "PLAYER",
						Description = "Upgrade your character.",
						Action = delegate
						{
							SwitchTo(PlayerPerksMenu, PlayerPerksCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "SHIP",
						Description = "Upgrade your ship.",
						Action = delegate
						{
							SwitchTo(ShipPerksMenu, ShipPerksCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "RESPEC",
						Description = "Reset your points.",
						Action = delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu, back: false);
						}
					},
					new CursorElement
					{
						Name = "CLOSE",
						Description = null,
						Action = delegate
						{
							Terminal.Clear();
							Terminal.Exit();
							Terminal.Submit("help");
						}
					}
				}
			};
			MainMenu = new BoxedScreenXP
			{
				Title = "PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select an action:"
					},
					new TextElement
					{
						Text = " "
					},
					MainMenuCursorMenu
				}
			};
			List<ITextElement> list = new List<ITextElement>();
			foreach (Perk p2 in Perk.PerksByType(Perk.Type.PLAYER))
			{
				if (!p2.IsActive)
				{
					continue;
				}
				list.Add(new PerkCursorElement(p2)
				{
					Action = delegate
					{
						BuyPerk(p2, delegate
						{
							SwitchTo(PlayerPerksMenu, PlayerPerksCursorMenu);
						});
					}
				});
			}
			list.Add(new CursorElement
			{
				Name = "BACK",
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			PlayerPerksCursorMenu = new CursorMenu
			{
				Elements = list
			};
			PlayerPerksMenu = new BoxedScreenXP
			{
				Title = "PLAYER PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select a perk to level:"
					},
					new TextElement
					{
						Text = " "
					},
					PlayerPerksCursorMenu
				}
			};
			List<ITextElement> list2 = new List<ITextElement>();
			foreach (Perk p in Perk.PerksByType(Perk.Type.SHIP))
			{
				if (!p.IsActive)
				{
					continue;
				}
				list2.Add(new PerkCursorElement(p)
				{
					Action = delegate
					{
						BuyPerk(p, delegate
						{
							SwitchTo(ShipPerksMenu, ShipPerksCursorMenu);
						});
					}
				});
			}
			list2.Add(new CursorElement
			{
				Name = "BACK",
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			ShipPerksCursorMenu = new CursorMenu
			{
				Elements = list2
			};
			ShipPerksMenu = new BoxedScreenXP
			{
				Title = "SHIP PERKS",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select a perk to level:"
					},
					new TextElement
					{
						Text = " "
					},
					ShipPerksCursorMenu
				}
			};
			List<ITextElement> list3 = new List<ITextElement>();
			list3.Add(new CursorElement
			{
				Name = "RESPEC PLAYER",
				Description = "Respec your player.",
				Action = delegate
				{
					if (!CanRespecPlayer)
					{
						CursorMenu cursorMenu2 = new CursorMenu
						{
							Elements = new List<ITextElement>
							{
								new CursorElement
								{
									Name = "BACK",
									Action = delegate
									{
										SwitchTo(RespecMenu, RespecCursorMenu);
									}
								}
							}
						};
						BoxedScreenXP box2 = new BoxedScreenXP
						{
							Title = "RESPEC PLAYER",
							Content = new List<ITextElement>
							{
								new TextElement
								{
									Text = "You can only respec inside your ship."
								},
								new TextElement
								{
									Text = " "
								},
								cursorMenu2
							}
						};
						SwitchTo(box2, cursorMenu2, back: false);
					}
					else
					{
						Confirm("RESPEC PLAYER", "Do you really want to respec your player?", delegate
						{
							AdvancedCompany.Network.Manager.Send(new Respec
							{
								PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
								Type = Perk.Type.PLAYER,
								Reset = false
							}, 0uL);
							SwitchTo(RespecMenu, RespecCursorMenu);
						}, delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu);
						});
					}
				}
			});
			list3.Add(new CursorElement
			{
				Name = "RESET PLAYER",
				Description = "Reset the progress of your player.",
				Action = delegate
				{
					Confirm("RESET PLAYER", "Do you really want to RESET your player?", delegate
					{
						AdvancedCompany.Network.Manager.Send(new Respec
						{
							PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
							Type = Perk.Type.PLAYER,
							Reset = true
						}, 0uL);
						SwitchTo(RespecMenu, RespecCursorMenu);
					}, delegate
					{
						SwitchTo(RespecMenu, RespecCursorMenu);
					});
				}
			});
			if (NetworkManager.Singleton.IsServer)
			{
				list3.Add(new CursorElement
				{
					Name = "RESPEC SHIP",
					Description = "Respec your ship.",
					Action = delegate
					{
						if (!CanRespecShip)
						{
							CursorMenu cursorMenu = new CursorMenu
							{
								Elements = new List<ITextElement>
								{
									new CursorElement
									{
										Name = "BACK",
										Action = delegate
										{
											SwitchTo(RespecMenu, RespecCursorMenu);
										}
									}
								}
							};
							BoxedScreenXP box = new BoxedScreenXP
							{
								Title = "RESPEC SHIP",
								Content = new List<ITextElement>
								{
									new TextElement
									{
										Text = "You can only respec the ship at the company building."
									},
									new TextElement
									{
										Text = " "
									},
									cursorMenu
								}
							};
							SwitchTo(box, cursorMenu, back: false);
						}
						else
						{
							Confirm("RESPEC SHIP", "Do you really want to respec your ship?", delegate
							{
								AdvancedCompany.Network.Manager.Send(new Respec
								{
									PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
									Type = Perk.Type.SHIP,
									Reset = false
								}, 0uL);
								SwitchTo(RespecMenu, RespecCursorMenu);
							}, delegate
							{
								SwitchTo(RespecMenu, RespecCursorMenu);
							});
						}
					}
				});
				list3.Add(new CursorElement
				{
					Name = "RESET SHIP",
					Description = "Reset the progress of your ship.",
					Action = delegate
					{
						Confirm("RESET SHIP", "Do you really want to RESET your ship?", delegate
						{
							AdvancedCompany.Network.Manager.Send(new Respec
							{
								PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
								Type = Perk.Type.SHIP,
								Reset = true
							}, 0uL);
							SwitchTo(RespecMenu, RespecCursorMenu);
						}, delegate
						{
							SwitchTo(RespecMenu, RespecCursorMenu);
						});
					}
				});
			}
			list3.Add(new CursorElement
			{
				Name = "BACK",
				Description = null,
				Action = delegate
				{
					SwitchTo(MainMenu, MainMenuCursorMenu);
				}
			});
			RespecCursorMenu = new CursorMenu
			{
				Elements = list3
			};
			RespecMenu = new BoxedScreenXP
			{
				Title = "RESPEC",
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = "Please select an action:"
					},
					new TextElement
					{
						Text = " "
					},
					RespecCursorMenu
				}
			};
		}

		public void Confirm(string title, string text, Action confirmAction, Action declineAction)
		{
			CursorMenu cursorMenu = new CursorMenu
			{
				Elements = new List<ITextElement>
				{
					new CursorElement
					{
						Name = "CONFIRM",
						Action = delegate
						{
							confirmAction();
						}
					},
					new CursorElement
					{
						Name = "DECLINE",
						Action = delegate
						{
							declineAction();
						}
					}
				}
			};
			BoxedScreenXP box = new BoxedScreenXP
			{
				Title = title,
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = text
					},
					new TextElement
					{
						Text = " "
					},
					cursorMenu
				}
			};
			SwitchTo(box, cursorMenu, back: false);
		}

		public void BuyPerk(Perk perk, Action backAction)
		{
			int num = 0;
			string title = "";
			bool flag = false;
			bool flag2 = false;
			int level = 0;
			if (perk.PerkType == Perk.Type.PLAYER)
			{
				title = "PLAYER PERKS";
				AdvancedCompany.Game.Player player = AdvancedCompany.Network.Manager.Lobby.Player();
				level = perk.GetLevel(player);
				if (level < perk.Levels)
				{
					level++;
					num = perk.GetNextPrice(player);
					flag2 = player.RemainingXP >= num;
				}
				else
				{
					flag = true;
				}
			}
			if (perk.PerkType == Perk.Type.SHIP)
			{
				title = "SHIP PERKS";
				Ship currentShip = AdvancedCompany.Network.Manager.Lobby.CurrentShip;
				level = perk.GetLevel(currentShip);
				if (level < perk.Levels)
				{
					level++;
					num = perk.GetNextPrice(currentShip);
					flag2 = currentShip.RemainingXP >= num;
				}
				else
				{
					flag = true;
				}
			}
			if (flag)
			{
				CursorMenu cursorMenu = new CursorMenu
				{
					Elements = new List<ITextElement>
					{
						new CursorElement
						{
							Name = "BACK",
							Action = delegate
							{
								backAction();
							}
						}
					}
				};
				BoxedScreenXP box = new BoxedScreenXP
				{
					Title = title,
					Content = new List<ITextElement>
					{
						new TextElement
						{
							Text = perk.DisplayDescription
						},
						new TextElement
						{
							Text = " "
						},
						new TextElement
						{
							Text = "This perk is already maxed out!"
						},
						new TextElement
						{
							Text = " "
						},
						cursorMenu
					}
				};
				SwitchTo(box, cursorMenu, back: false);
				return;
			}
			if (!flag2)
			{
				CursorMenu cursorMenu2 = new CursorMenu
				{
					Elements = new List<ITextElement>
					{
						new CursorElement
						{
							Name = "BACK",
							Action = delegate
							{
								backAction();
							}
						}
					}
				};
				BoxedScreenXP box2 = new BoxedScreenXP
				{
					Title = title,
					Content = new List<ITextElement>
					{
						new TextElement
						{
							Text = perk.DisplayDescription
						},
						new TextElement
						{
							Text = " "
						},
						new TextElement
						{
							Text = "You can't afford this perk. You need " + num + "XP!"
						},
						new TextElement
						{
							Text = " "
						},
						cursorMenu2
					}
				};
				SwitchTo(box2, cursorMenu2, back: false);
				return;
			}
			CursorMenu cursorMenu3 = new CursorMenu
			{
				Elements = new List<ITextElement>
				{
					new CursorElement
					{
						Name = "CONFIRM",
						Action = delegate
						{
							AdvancedCompany.Network.Manager.Send(new ChangePerk
							{
								PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
								ID = perk.ID,
								Level = level
							}, 0uL);
							backAction();
						}
					},
					new CursorElement
					{
						Name = "DECLINE",
						Action = delegate
						{
							backAction();
						}
					}
				}
			};
			BoxedScreenXP box3 = new BoxedScreenXP
			{
				Title = title,
				Content = new List<ITextElement>
				{
					new TextElement
					{
						Text = perk.DisplayDescription
					},
					new TextElement
					{
						Text = " "
					},
					new TextElement
					{
						Text = "Do you want to buy this perk for " + num + "XP?"
					},
					new TextElement
					{
						Text = " "
					},
					cursorMenu3
				}
			};
			SwitchTo(box3, cursorMenu3, back: false);
		}

		public void SwitchTo(BoxedScreenXP box, CursorMenu menu, bool back = true)
		{
			CurrentScreen = box;
			CurrentCursorMenu = menu;
			if (!back)
			{
				menu.SelectedElement = 0;
			}
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			Init();
			Terminal = terminal;
			Terminal.DeactivateInput();
			SwitchTo(MainMenu, MainMenuCursorMenu, back: false);
		}

		public void Exit()
		{
		}

		public void Update()
		{
			Terminal.SetText(CurrentScreen.GetText(58));
			if (CurrentCursorMenu != null)
			{
				if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement--;
				}
				if (((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.SelectedElement++;
				}
				if (((ButtonControl)Keyboard.current.enterKey).wasPressedThisFrame)
				{
					CurrentCursorMenu.Execute();
				}
			}
		}

		public void Submit(string text)
		{
		}
	}
	[Bootable]
	internal class ShipXPApplication : IApplication
	{
		public static void Boot()
		{
			MobileTerminal.RegisterApplication("shipxp", new ShipXPApplication());
		}

		public void Exit()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			int result;
			if (!NetworkManager.Singleton.IsServer)
			{
				terminal.WriteLine("Only host is allowed to run this command!");
			}
			else if (args.Length != 0 && int.TryParse(args[0], out result))
			{
				AdvancedCompany.Network.Manager.Send(new GrantShipXP
				{
					XP = result
				}, 0uL);
				terminal.WriteLine($"Granted {result} XP to the ship.");
			}
			else
			{
				terminal.WriteLine("Usage: shipxp [amount]");
			}
			terminal.Exit();
		}

		public void Submit(string text)
		{
		}

		public void Update()
		{
		}
	}
	[Bootable]
	internal class StoreApplication : IApplication
	{
		private MobileTerminal Terminal;

		private IScreen CurrentScreen;

		private BoxedScreenStore StoreScreen;

		private CursorMenu CurrentCursorMenu;

		private TextElement CostNode;

		private CursorElement BuyNode;

		public static void Boot()
		{
			MobileTerminal.RegisterApplication("store", new StoreApplication());
			AdvancedCompany.Network.Manager.AddListener(delegate(BuyItems msg)
			{
				if (NetworkManager.Singleton.IsServer)
				{
					Terminal terminal = AdvancedCompany.Game.Manager.Terminal;
					terminal.numberOfItemsInDropship += msg.Items.Length;
					AdvancedCompany.Game.Manager.Terminal.orderedItemsFromTerminal.AddRange(msg.Items);
				}
				for (int i = 0; i < msg.Unlockables.Length; i++)
				{
					if (StartOfRound.Instance.unlockablesList.unlockables.Count > msg.Unlockables[i] && StartOfRound.Instance.unlockablesList.unlockables[msg.Unlockables[i]] != null)
					{
						if (NetworkManager.Singleton.IsServer)
						{
							StartOfRound.Instance.UnlockShipObject(msg.Unlockables[i]);
						}
						StartOfRound.Instance.unlockablesList.unlockables[msg.Unlockables[i]].hasBeenUnlockedByPlayer = true;
					}
					else
					{
						Plugin.Log.LogWarning((object)("Unlockable " + msg.Unlockables[i] + " is unavailable!"));
					}
				}
				AdvancedCompany.Game.Manager.Terminal.groupCredits = msg.NewCredits;
			});
		}

		public void Exit()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			if (!AdvancedCompany.Network.Manager.Lobby.Player().Controller.isInHangarShipRoom)
			{
				terminal.WriteLine("You can't buy items outside of the ship.");
				terminal.Exit();
				return;
			}
			int buyIndex = 0;
			Terminal = terminal;
			CurrentCursorMenu = new CursorMenu
			{
				Elements = new List<ITextElement>()
			};
			CurrentCursorMenu.Elements.Add(new TextElement
			{
				Text = "∎ ITEMS ∎"
			});
			for (int i = 0; i < AdvancedCompany.Game.Manager.Items.BuyableItems.Count; i++)
			{
				Item val = AdvancedCompany.Game.Manager.Items.BuyableItems[i];
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(val.itemName);
				if (byItemName == null || byItemName.Active)
				{
					CurrentCursorMenu.Elements.Add(new ItemCursorElement(val)
					{
						Action = delegate
						{
							CurrentCursorMenu.SelectedElement = buyIndex;
						}
					});
				}
			}
			bool flag = true;
			for (int j = 0; j < AdvancedCompany.Game.Manager.Items.ShipUpgrades.Count; j++)
			{
				UnlockableItem val2 = AdvancedCompany.Game.Manager.Items.ShipUpgrades[j];
				if (!AdvancedCompany.Game.Manager.Items.UnlockablePrices.ContainsKey(val2) || !AdvancedCompany.Game.Manager.Items.IsUnlockableBuyable(val2))
				{
					continue;
				}
				int num = val2.maxNumber - ((val2.hasBeenUnlockedByPlayer || val2.alreadyUnlocked) ? 1 : 0);
				if (num > 0)
				{
					if (flag)
					{
						CurrentCursorMenu.Elements.Add(new TextElement
						{
							Text = " "
						});
						CurrentCursorMenu.Elements.Add(new TextElement
						{
							Text = "∎ SHIP UPGRADES ∎"
						});
						flag = false;
					}
					CurrentCursorMenu.Elements.Add(new UnlockableCursorElement(val2, num)
					{
						Action = delegate
						{
							CurrentCursorMenu.SelectedElement = buyIndex;
						}
					});
				}
			}
			List<UnlockableItem> list = new List<UnlockableItem>();
			for (int k = 0; k < AdvancedCompany.Game.Manager.Terminal.ShipDecorSelection.Count; k++)
			{
				try
				{
					list.Add(StartOfRound.Instance.unlockablesList.unlockables[AdvancedCompany.Game.Manager.Terminal.ShipDecorSelection[k].shipUnlockableID]);
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while adding ship decor:");
					Plugin.Log.LogError((object)ex);
				}
			}
			bool flag2 = true;
			for (int l = 0; l < AdvancedCompany.Game.Manager.Items.Decorations.Count; l++)
			{
				UnlockableItem val3 = AdvancedCompany.Game.Manager.Items.Decorations[l];
				if (!AdvancedCompany.Game.Manager.Items.UnlockablePrices.ContainsKey(val3) || !list.Contains(val3) || !AdvancedCompany.Game.Manager.Items.IsUnlockableBuyable(val3))
				{
					continue;
				}
				int num2 = val3.maxNumber - ((val3.hasBeenUnlockedByPlayer || val3.alreadyUnlocked) ? 1 : 0);
				if (num2 > 0)
				{
					if (flag2)
					{
						CurrentCursorMenu.Elements.Add(new TextElement
						{
							Text = " "
						});
						CurrentCursorMenu.Elements.Add(new TextElement
						{
							Text = "∎ DECORATIONS ∎"
						});
						flag2 = false;
					}
					CurrentCursorMenu.Elements.Add(new UnlockableCursorElement(val3, num2)
					{
						Action = delegate
						{
							CurrentCursorMenu.SelectedElement = buyIndex;
						}
					});
				}
			}
			CurrentCursorMenu.Elements.Add(new TextElement
			{
				Text = " "
			});
			CurrentCursorMenu.Elements.Add(new CursorElement
			{
				Name = "BACK",
				Action = delegate
				{
					Terminal.Clear();
					Terminal.Exit();
					Terminal.Submit("help");
				}
			});
			buyIndex = CurrentCursorMenu.Elements.Count;
			BuyNode = new CursorElement
			{
				Name = "BUY",
				Action = delegate
				{
					Buy();
				}
			};
			CurrentCursorMenu.Elements.Add(BuyNode);
			CurrentCursorMenu.SelectedElement = 1;
			StoreScreen = new BoxedScreenStore
			{
				Title = "COMPANY STORE",
				TotalCost = 100,
				Content = new List<ITextElement>
				{
					new ScrollBox(15)
					{
						Content = CurrentCursorMenu
					}
				}
			};
			CurrentScreen = StoreScreen;
			Terminal.DeactivateInput();
		}

		public void Submit(string text)
		{
		}

		internal void Buy()
		{
			int num = 0;
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			for (int i = 0; i < CurrentCursorMenu.Elements.Count; i++)
			{
				if (CurrentCursorMenu.Elements[i] is ItemCursorElement itemCursorElement)
				{
					int num2 = -1;
					for (int j = 0; j < AdvancedCompany.Game.Manager.Terminal.buyableItemsList.Length; j++)
					{
						if ((Object)(object)AdvancedCompany.Game.Manager.Terminal.buyableItemsList[j] == (Object)(object)itemCursorElement.Item)
						{
							num2 = j;
							break;
						}
					}
					if (num2 > -1)
					{
						num += itemCursorElement.Amount * AdvancedCompany.Game.Manager.Items.GetItemPrice(itemCursorElement.Item, discount: true);
						for (int k = 0; k < itemCursorElement.Amount; k++)
						{
							list.Add(num2);
						}
					}
				}
				if (CurrentCursorMenu.Elements[i] is UnlockableCursorElement unlockableCursorElement)
				{
					int num3 = StartOfRound.Instance.unlockablesList.unlockables.IndexOf(unlockableCursorElement.Item);
					if (num3 > -1 && unlockableCursorElement.Amount > 0)
					{
						num += unlockableCursorElement.Amount * AdvancedCompany.Game.Manager.Items.GetUnlockablePrice(unlockableCursorElement.Item);
						list2.Add(num3);
					}
				}
			}
			StoreScreen.TotalCost = num;
			int groupCredits = AdvancedCompany.Game.Manager.Terminal.groupCredits;
			if (groupCredits >= num)
			{
				AdvancedCompany.Network.Manager.Send(new BuyItems
				{
					Items = list.ToArray(),
					Unlockables = list2.ToArray(),
					NewCredits = groupCredits - num
				}, 0uL);
				Terminal.Exit();
				Terminal.Clear();
				Terminal.WriteLine("Thanks for your purchase! Your ordered items are on the way!");
			}
		}

		public void Update()
		{
			Terminal.SetText(CurrentScreen.GetText(58), scrollToTop: false);
			if (CurrentCursorMenu == null)
			{
				return;
			}
			if (((ButtonControl)Keyboard.current.leftArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.aKey).wasPressedThisFrame)
			{
				ITextElement textElement = CurrentCursorMenu.Elements[CurrentCursorMenu.SelectedElement];
				if (textElement is ItemCursorElement itemCursorElement)
				{
					itemCursorElement.Amount = Mathf.Max(0, itemCursorElement.Amount - 1);
				}
				if (textElement is UnlockableCursorElement unlockableCursorElement)
				{
					unlockableCursorElement.Amount = Mathf.Max(0, unlockableCursorElement.Amount - 1);
				}
			}
			if (((ButtonControl)Keyboard.current.rightArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.dKey).wasPressedThisFrame)
			{
				ITextElement textElement2 = CurrentCursorMenu.Elements[CurrentCursorMenu.SelectedElement];
				if (textElement2 is ItemCursorElement itemCursorElement2)
				{
					itemCursorElement2.Amount = Mathf.Max(0, itemCursorElement2.Amount + 1);
				}
				if (textElement2 is UnlockableCursorElement unlockableCursorElement2)
				{
					unlockableCursorElement2.Amount = Mathf.Min(unlockableCursorElement2.MaxAmount, unlockableCursorElement2.Amount + 1);
				}
			}
			if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.wKey).wasPressedThisFrame)
			{
				CurrentCursorMenu.SelectedElement--;
			}
			if (((ButtonControl)Keyboard.current.downArrowKey).wasPressedThisFrame || ((ButtonControl)Keyboard.current.sKey).wasPressedThisFrame)
			{
				CurrentCursorMenu.SelectedElement++;
			}
			int num = 0;
			for (int i = 0; i < CurrentCursorMenu.Elements.Count; i++)
			{
				if (CurrentCursorMenu.Elements[i] is ItemCursorElement itemCursorElement3)
				{
					num += itemCursorElement3.Amount * AdvancedCompany.Game.Manager.Items.GetItemPrice(itemCursorElement3.Item, discount: true);
				}
				if (CurrentCursorMenu.Elements[i] is UnlockableCursorElement unlockableCursorElement3)
				{
					num += unlockableCursorElement3.Amount * AdvancedCompany.Game.Manager.Items.GetUnlockablePrice(unlockableCursorElement3.Item);
				}
			}
			StoreScreen.TotalCost = num;
			int groupCredits = AdvancedCompany.Game.Manager.Terminal.groupCredits;
			if (groupCredits < num)
			{
				BuyNode.Name = "<color=#666666>BUY</color>";
			}
			else
			{
				BuyNode.Name = "<color=#66FF66>BUY</color>";
			}
			if (((ButtonControl)Keyboard.current.enterKey).wasPressedThisFrame)
			{
				CurrentCursorMenu.Execute();
			}
		}
	}
	[Bootable]
	internal class XPApplication : IApplication
	{
		public static void Boot()
		{
			MobileTerminal.RegisterApplication("xp", new XPApplication());
		}

		public void Exit()
		{
		}

		public void Main(MobileTerminal terminal, string[] args)
		{
			int result;
			if (!NetworkManager.Singleton.IsServer)
			{
				terminal.WriteLine("Only host is allowed to run this command!");
			}
			else if (args.Length > 1 && int.TryParse(args[1], out result))
			{
				AdvancedCompany.Game.Player player = null;
				player = AdvancedCompany.Network.Manager.Lobby.Player(args[0]);
				if (player == null && int.TryParse(args[0], out var result2))
				{
					player = AdvancedCompany.Network.Manager.Lobby.Player(result2);
				}
				if (player == null)
				{
					terminal.WriteLine("Player " + args[0] + " couldn't be found!");
				}
				else
				{
					AdvancedCompany.Network.Manager.Send(new GrantPlayerXP
					{
						All = false,
						PlayerNum = player.PlayerNum,
						XP = result
					}, 0uL);
					terminal.WriteLine($"Granted {result} XP to {player.Controller.playerUsername}.");
				}
			}
			else
			{
				terminal.WriteLine("Usage: xp [playerNum|playerName] [amount]");
			}
			terminal.Exit();
		}

		public void Submit(string text)
		{
		}

		public void Update()
		{
		}
	}
}
namespace AdvancedCompany.PostProcessing
{
	[Serializable]
	[LoadAssets]
	[VolumeComponentMenu("Post-processing/Custom/Doom")]
	public sealed class DoomEffect : CustomPostProcessVolumeComponent, IPostProcessComponent
	{
		[Tooltip("Controls the intensity of the effect.")]
		public ClampedFloatParameter intensity = new ClampedFloatParameter(0f, 0f, 1f, false);

		private static Material Material;

		private Material m_Material;

		public override CustomPostProcessInjectionPoint injectionPoint => (CustomPostProcessInjectionPoint)2;

		public bool IsActive()
		{
			return (Object)(object)m_Material != (Object)null && ((VolumeParameter<float>)(object)intensity).value > 0f;
		}

		public static void LoadAssets(AssetBundle assets)
		{
			Material = assets.LoadAsset<Material>("Assets/Shaders/Doom.mat");
		}

		public override void Setup()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			m_Material = new Material(Material);
		}

		public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_Material == (Object)null))
			{
				m_Material.SetFloat("_Intensity", ((VolumeParameter<float>)(object)intensity).value);
				if (!(((VolumeParameter<float>)(object)intensity).value <= 0f))
				{
					float num = 640f;
					m_Material.SetFloat("_ScreenWidth", num);
					m_Material.SetFloat("_ScreenHeight", num * 3f / 4f);
					cmd.Blit(RTHandle.op_Implicit(source), RTHandle.op_Implicit(destination), m_Material, 0);
				}
			}
		}

		public override void Cleanup()
		{
			CoreUtils.Destroy((Object)(object)m_Material);
		}
	}
	[Serializable]
	[LoadAssets]
	[VolumeComponentMenu("Post-processing/Custom/VisionEnhancer")]
	public sealed class VisionEnhancer : CustomPostProcessVolumeComponent, IPostProcessComponent
	{
		[Tooltip("Controls the intensity of the effect.")]
		public ClampedFloatParameter intensity = new ClampedFloatParameter(0f, 0f, 1f, false);

		[Tooltip("Controls the intensity of the effect.")]
		public ClampedFloatParameter brightness = new ClampedFloatParameter(0f, 0f, 1f, false);

		private static Material Material;

		private Material m_Material;

		public override CustomPostProcessInjectionPoint injectionPoint => (CustomPostProcessInjectionPoint)2;

		public bool IsActive()
		{
			return (Object)(object)m_Material != (Object)null && ((VolumeParameter<float>)(object)intensity).value > 0f;
		}

		public static void LoadAssets(AssetBundle assets)
		{
			Material = assets.LoadAsset<Material>("Assets/Shaders/VisionEnhancer.mat");
		}

		public override void Setup()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			m_Material = new Material(Material);
		}

		public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_Material == (Object)null))
			{
				m_Material.SetFloat("_Intensity", ((VolumeParameter<float>)(object)intensity).value);
				m_Material.SetFloat("_Brightness", ((VolumeParameter<float>)(object)brightness).value);
				m_Material.SetTexture("_MainTex", RTHandle.op_Implicit(source));
				cmd.Blit(RTHandle.op_Implicit(source), RTHandle.op_Implicit(destination), m_Material, 0);
			}
		}

		public override void Cleanup()
		{
			CoreUtils.Destroy((Object)(object)m_Material);
		}
	}
	[Bootable]
	public sealed class VisionEnhancerEffect
	{
		private static GameObject LightAndFog;

		private static bool Active;

		private static float Phase;

		private static VisionEnhancer Instance;

		private static HDRP.PostProcessInstance PPInstance;

		public static void Boot()
		{
			PPInstance = HDRP.AddPostProcessing<VisionEnhancer>(HDRP.InjectionPoint.AFTER_POSTPROCESS);
			Instance = (VisionEnhancer)(object)PPInstance.CurrentInstance;
			HDRP.PostProcessInstance pPInstance = PPInstance;
			pPInstance.OnInstanceChanged = (HDRP.PostProcessInstance.InstanceChanged)Delegate.Combine(pPInstance.OnInstanceChanged, (HDRP.PostProcessInstance.InstanceChanged)delegate(VolumeComponent old, VolumeComponent instance)
			{
				Instance = (VisionEnhancer)(object)instance;
			});
		}

		public static void Initialize()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			Active = false;
			Phase = 0f;
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(GameNetworkManager.Instance.localPlayerController);
			LightAndFog = new GameObject("VisionEnhancerLight");
			LightAndFog.transform.parent = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			LightAndFog.transform.localPosition = new Vector3(0f, 0f, 0.5f);
			LightAndFog.transform.localRotation = Quaternion.identity;
			LocalVolumetricFog val = LightAndFog.AddComponent<LocalVolumetricFog>();
			val.parameters.size = new Vector3(50f, 50f, 50f);
			val.parameters.falloffMode = (LocalVolumetricFogFalloffMode)1;
			val.parameters.blendingMode = (LocalVolumetricFogBlendingMode)0;
			val.parameters.anisotropy = 25f;
			val.parameters.meanFreePath = 25f;
			GameObject val2 = new GameObject("Light1");
			val2.transform.parent = LightAndFog.transform;
			val2.transform.localPosition = new Vector3(8f, 9.1f, -1.5f);
			val2.transform.localRotation = Quaternion.Euler(50f, -61f, -68f);
			Light val3 = val2.AddComponent<Light>();
			val3.color = new Color(0f, 1f, 0f);
			val3.type = (LightType)0;
			val3.shape = (LightShape)2;
			val3.cullingMask = 2147483519;
			HDAdditionalLightData val4 = val2.AddComponent<HDAdditionalLightData>();
			val4.SetBoxSpotSize(new Vector2(500f, 500f));
			val4.SetIntensity(100f, (LightUnit)2);
			val4.spotLightShape = (SpotLightShape)2;
			val4.affectsVolumetric = true;
			val4.volumetricDimmer = 0.1f;
			val4.range = 1000f;
			val4.lightDimmer = 1f;
			val4.SetCullingMask(2147483519);
			GameObject val5 = new GameObject("Light2");
			val5.transform.parent = LightAndFog.transform;
			val5.transform.localPosition = new Vector3(8f, 6.5f, 8f);
			val5.transform.localRotation = Quaternion.Euler(56f, 114f, 110f);
			Light val6 = val5.AddComponent<Light>();
			val6.color = new Color(0f, 1f, 0f);
			val6.type = (LightType)0;
			val6.shape = (LightShape)2;
			val6.cullingMask = 2147483519;
			HDAdditionalLightData val7 = val5.AddComponent<HDAdditionalLightData>();
			val7.SetBoxSpotSize(new Vector2(500f, 500f));
			val7.SetIntensity(100f, (LightUnit)2);
			val7.spotLightShape = (SpotLightShape)2;
			val7.SetCullingMask(2147483519);
			val7.affectsVolumetric = true;
			val7.volumetricDimmer = 0.1f;
			val7.range = 1000f;
			val7.lightDimmer = 1f;
			LightAndFog.SetActive(false);
		}

		public static void Activate()
		{
			Active = true;
		}

		public static void Deactivate()
		{
			Active = false;
		}

		public static void Update()
		{
			if (Active)
			{
				Phase = Mathf.Clamp01(Phase + Time.deltaTime * 2f);
			}
			else
			{
				Phase = Mathf.Clamp01(Phase - Time.deltaTime * 5f);
			}
			if ((Object)(object)Instance != (Object)null)
			{
				if (((VolumeParameter<float>)(object)Instance.intensity).value != Phase)
				{
					((VolumeParameter<float>)(object)Instance.intensity).value = Phase;
				}
				float num = 0.3f + Mathf.Clamp01(ClientConfiguration.Instance.Graphics.VisionEnhancerBrightness) * 0.4f;
				if (((VolumeParameter<float>)(object)Instance.brightness).value != num)
				{
					((VolumeParameter<float>)(object)Instance.brightness).value = num;
				}
				if (Phase > 0f && !LightAndFog.activeSelf)
				{
					MeshRenderer component = ((Component)GameNetworkManager.Instance.localPlayerController.localVisor.GetChild(0)).GetComponent<MeshRenderer>();
					((Renderer)component).materials[2].SetFloat("_Metallic", 1f);
					((Renderer)component).materials[2].SetFloat("_Smoothness", 0f);
					LightAndFog.SetActive(true);
				}
				if (Phase <= 0f && LightAndFog.activeSelf)
				{
					MeshRenderer component2 = ((Component)GameNetworkManager.Instance.localPlayerController.localVisor.GetChild(0)).GetComponent<MeshRenderer>();
					((Renderer)component2).materials[2].SetFloat("_Metallic", 0.69f);
					((Renderer)component2).materials[2].SetFloat("_Smoothness", 0.5f);
					LightAndFog.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch]
	internal class Volumes
	{
		private static Volume Volume;

		internal static void Initialize()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("RenderVolume");
			Volume = val.AddComponent<Volume>();
			Volume.isGlobal = true;
			Volume.priority = 1000f;
		}

		internal static void ChangeEnvironment(string moonID, bool onMoon, bool inFacility, bool underwater, bool alive)
		{
			HDRP.PostProcessingFlags type = HDRP.PostProcessingFlags.ORBIT;
			if (onMoon && inFacility)
			{
				type = HDRP.PostProcessingFlags.INSIDE;
			}
			if (onMoon && !inFacility && !underwater)
			{
				type = HDRP.PostProcessingFlags.OUTSIDE;
			}
			if (onMoon && underwater)
			{
				type = HDRP.PostProcessingFlags.UNDERWATER;
			}
			Volume.sharedProfile = HDRP.GetProfile(moonID, type);
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPrefix]
		private static void Initialize(StartOfRound __instance)
		{
			Initialize();
			ChangeEnvironment(null, onMoon: false, inFacility: false, underwater: false, alive: true);
		}

		[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayer")]
		[HarmonyPostfix]
		private static void EntranceTeleport(EntranceTeleport __instance)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, GameNetworkManager.Instance.localPlayerController.isInsideFactory, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		[HarmonyPostfix]
		private static void ReviveDeadPlayers(StartOfRound __instance)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, GameNetworkManager.Instance.localPlayerController.isInsideFactory, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
		}

		[HarmonyPatch(typeof(ShipTeleporter), "TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyPostfix]
		private static void TeleportPlayerOutWithInverseTeleporter(ShipTeleporter __instance, int playerObj)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, StartOfRound.Instance.allPlayerScripts[playerObj].isInsideFactory, underwater: false, StartOfRound.Instance.allPlayerScripts[playerObj].isPlayerDead);
		}

		[HarmonyPatch(typeof(ShipTeleporter), "beamUpPlayer")]
		[HarmonyPrefix]
		private static void beamUpPlayer(ShipTeleporter __instance)
		{
			if ((Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer != (Object)null && (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, inFacility: false, underwater: false, StartOfRound.Instance.mapScreen.targetedPlayer.isPlayerDead);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "openingDoorsSequence")]
		[HarmonyPrefix]
		private static void openingDoorsSequence(StartOfRound __instance)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, inFacility: false, underwater: false, alive: false);
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		[HarmonyPostfix]
		private static void ShipLeave(StartOfRound __instance)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: false, inFacility: false, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeaveAutomatically")]
		[HarmonyPostfix]
		private static void ShipLeaveAutomatically(StartOfRound __instance)
		{
			ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: false, inFacility: false, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetFaceUnderwaterServerRpc")]
		[HarmonyPostfix]
		private static void SetFaceUnderwaterServerRpc(PlayerControllerB __instance)
		{
			if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, GameNetworkManager.Instance.localPlayerController.isInsideFactory, underwater: true, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetFaceOutOfWaterServerRpc")]
		[HarmonyPostfix]
		private static void SetFaceOutOfWaterServerRpc(PlayerControllerB __instance)
		{
			if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, GameNetworkManager.Instance.localPlayerController.isInsideFactory, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
			}
		}
	}
}
namespace AdvancedCompany.Patches
{
	[LoadAssets]
	[HarmonyPatch]
	internal class AnimationPatches
	{
		internal static RuntimeAnimatorController PlayerAnimator;

		internal static RuntimeAnimatorController OtherPlayerAnimator;

		public static void LoadAssets(AssetBundle assets)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			PlayerAnimator = (RuntimeAnimatorController)new AnimatorOverrideController(assets.LoadAsset<RuntimeAnimatorController>("Assets/Animators/metarig.controller"));
			OtherPlayerAnimator = (RuntimeAnimatorController)new AnimatorOverrideController(assets.LoadAsset<RuntimeAnimatorController>("Assets/Animators/metarigOtherPlayers.controller"));
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPrefix]
		private static void Initialize(StartOfRound __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			__instance.otherClientsAnimatorController = (RuntimeAnimatorController)new AnimatorOverrideController(OtherPlayerAnimator);
			__instance.localClientAnimatorController = (RuntimeAnimatorController)new AnimatorOverrideController(PlayerAnimator);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Awake")]
		[HarmonyPostfix]
		public static void Awake(PlayerControllerB __instance)
		{
			__instance.playerBodyAnimator.runtimeAnimatorController = OtherPlayerAnimator;
		}
	}
	[HarmonyPatch]
	internal class BalancingPatches
	{
		[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		public static void ResetMultiplier(RoundManager __instance)
		{
			__instance.scrapValueMultiplier = 0.4f;
			__instance.scrapAmountMultiplier = 1f;
		}

		[HarmonyPatch(typeof(LungProp), "Start")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "LethalRadiation" })]
		public static void ChangeLungPrice(LungProp __instance)
		{
			((GrabbableObject)__instance).scrapValue = (int)((float)((GrabbableObject)__instance).scrapValue * AdvancedCompany.Game.Manager.Moons.GetScrapValueModifierOnly(RoundManager.Instance));
		}

		[HarmonyPatch(typeof(LungProp), "EquipItem")]
		[HarmonyPrefix]
		[HarmonyAfter(new string[] { "me.loaforc.facilitymeltdown" })]
		public static void ChangeLungPrice2(LungProp __instance)
		{
			if (Chainloader.PluginInfos.ContainsKey("me.loaforc.facilitymeltdown") && __instance.isLungDocked)
			{
				((GrabbableObject)__instance).scrapValue = (int)((float)((GrabbableObject)__instance).scrapValue * AdvancedCompany.Game.Manager.Moons.GetScrapValueModifierOnly(RoundManager.Instance));
			}
		}
	}
	[HarmonyPatch]
	internal class Compability
	{
		public static AnimatorOverrideController OthersOverrideController;

		public static AnimatorOverrideController LocalOverrideController;

		[HarmonyPatch(typeof(PreInitSceneScript), "Awake")]
		[HarmonyPostfix]
		public static void ApplyPatch()
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			if (!Chainloader.PluginInfos.ContainsKey("MoreEmotes"))
			{
				return;
			}
			Assembly assembly = ((object)Chainloader.PluginInfos["MoreEmotes"].Instance).GetType().Assembly;
			if (assembly != null)
			{
				Plugin.UseAnimationOverride = true;
				Plugin.Log.LogMessage((object)"Found more emotes. Trying to add AnimatorOverrideController...");
				Type type = assembly.GetType("MoreEmotes.Patch.EmotePatch");
				FieldInfo field = type.GetField("local", BindingFlags.Static | BindingFlags.Public);
				RuntimeAnimatorController val = (RuntimeAnimatorController)field.GetValue(null);
				if ((Object)(object)val != (Object)null && !(val is AnimatorOverrideController))
				{
					val = (RuntimeAnimatorController)new AnimatorOverrideController(val);
				}
				field.SetValue(null, val);
				LocalOverrideController = (AnimatorOverrideController)val;
				FieldInfo field2 = type.GetField("others", BindingFlags.Static | BindingFlags.Public);
				RuntimeAnimatorController val2 = (RuntimeAnimatorController)field2.GetValue(null);
				if ((Object)(object)val2 != (Object)null && !(val2 is AnimatorOverrideController))
				{
					val2 = (RuntimeAnimatorController)new AnimatorOverrideController(val2);
				}
				field2.SetValue(null, val2);
				OthersOverrideController = (AnimatorOverrideController)val2;
			}
		}
	}
	[HarmonyPatch]
	internal class DebugPatches
	{
	}
	[HarmonyPatch]
	internal class EnemyAICollisionDetect
	{
		[HarmonyPatch(typeof(EnemyAICollisionDetect), "IHittable.Hit")]
		[HarmonyPrefix]
		private static void Hit(ref int force, Vector3 hitDirection, PlayerControllerB playerWhoHit, bool playHitSFX)
		{
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)playerWhoHit && Random.value < Perks.GetMultiplier("DealDamage"))
			{
				force += 100;
			}
		}
	}
	[HarmonyPatch]
	internal class FieldPatches
	{
		internal static Dictionary<Type, List<(string, MethodType)>> Patches = new Dictionary<Type, List<(string, MethodType)>>
		{
			{
				typeof(Terminal),
				new List<(string, MethodType)>
				{
					("LoadNewNodeIfAffordable", (MethodType)0),
					("OnSubmit", (MethodType)0),
					("SetItemSales", (MethodType)0),
					("TextPostProcess", (MethodType)0)
				}
			},
			{
				typeof(PlayerControllerB),
				new List<(string, MethodType)>
				{
					("BeginGrabObject", (MethodType)0),
					("GrabObject", (MethodType)5),
					("GrabObjectClientRpc", (MethodType)0),
					("DespawnHeldObjectOnClient", (MethodType)0),
					("SetObjectAsNoLongerHeld", (MethodType)0),
					("PlaceGrabbableObject", (MethodType)0),
					("DestroyItemInSlot", (MethodType)0)
				}
			},
			{
				typeof(RoundManager),
				new List<(string, MethodType)>
				{
					("SpawnScrapInLevel", (MethodType)0),
					("GenerateNewFloor", (MethodType)0),
					("PlotOutEnemiesForNextHour", (MethodType)0),
					("SpawnDaytimeEnemiesOutside", (MethodType)0),
					("SpawnRandomDaytimeEnemy", (MethodType)0),
					("SpawnRandomOutsideEnemy", (MethodType)0),
					("SpawnEnemyGameObject", (MethodType)0),
					("AssignRandomEnemyToVent", (MethodType)0),
					("EnemyCannotBeSpawned", (MethodType)0),
					("DespawnEnemyGameObject", (MethodType)0),
					("ResetEnemyTypesSpawnedCounts", (MethodType)0),
					("RefreshEnemiesList", (MethodType)0),
					("BeginEnemySpawning", (MethodType)0)
				}
			},
			{
				typeof(GiftBoxItem),
				new List<(string, MethodType)> { ("Start", (MethodType)0) }
			},
			{
				typeof(EnemyAI),
				new List<(string, MethodType)> { ("SubtractFromPowerLevel", (MethodType)0) }
			},
			{
				typeof(EnemyVent),
				new List<(string, MethodType)> { ("SyncVentSpawnTimeClientRpc", (MethodType)0) }
			},
			{
				typeof(GameNetworkManager),
				new List<(string, MethodType)> { ("ConvertUnsellableItemsToCredits", (MethodType)0) }
			}
		};

		[HarmonyPatch(typeof(PreInitSceneScript), "Awake")]
		[HarmonyPrefix]
		public static void Awake()
		{
			AdvancedCompany.Lib.Cosmetics.LoadNew();
			if (Plugin.AssembliesToScan.Count > 0)
			{
				for (int i = 0; i < Plugin.AssembliesToScan.Count; i++)
				{
					Plugin.Log.LogDebug((object)("Patching " + Plugin.AssembliesToScan[i].FullName));
					ScanAssemblyForFields(Plugin.AssembliesToScan[i]);
					Plugin.Log.LogDebug((object)("Patched " + Plugin.AssembliesToScan[i].FullName));
				}
				Plugin.AssembliesToScan.Clear();
			}
		}

		public static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
		{
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				Plugin.Log.LogWarning((object)("Mod " + assembly.FullName + " tried to reference a missing assembly " + ex.Message + ". Trying to parse other types..."));
				List<Type> list = new List<Type>();
				Type[] types = ex.Types;
				foreach (Type type in types)
				{
					try
					{
						if (type != null && type.Assembly == assembly)
						{
							list.Add(type);
						}
					}
					catch (BadImageFormatException)
					{
					}
				}
				return list;
			}
			catch (Exception ex3)
			{
				Plugin.Log.LogWarning((object)("Failed to parse mod " + assembly.FullName + ":"));
				Plugin.Log.LogWarning((object)ex3);
				return new List<Type>();
			}
		}

		internal static void ScanAssemblyForFields(Assembly assembly)
		{
			try
			{
				IEnumerable<Type> loadableTypes = GetLoadableTypes(assembly);
				foreach (Type item in loadableTypes)
				{
					ScanTypeForFields(item);
				}
			}
			catch (ReflectionTypeLoadException ex)
			{
				Plugin.Log.LogWarning((object)("Mod " + assembly.FullName + " tried to reference a missing reference " + ex.Message));
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("Failed to parse mod " + assembly.FullName + ":"));
				Plugin.Log.LogWarning((object)ex2);
			}
		}

		internal static void ScanTypeForFields(Type type)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			try
			{
				if (type.IsInterface || type.IsGenericTypeDefinition)
				{
					return;
				}
				Type[] nestedTypes = type.GetNestedTypes();
				Type[] array = nestedTypes;
				foreach (Type type2 in array)
				{
					ScanTypeForFields(type2);
				}
				Harmony val = new Harmony("AdvancedCompany");
				HarmonyMethod val2 = new HarmonyMethod(typeof(AdvancedCompany.Game.Manager).GetMethod("PatchFields", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic));
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name == "MoveNext" || methodInfo.IsAbstract || !MethodBaseExtensions.HasMethodBody((MethodBase)methodInfo) || methodInfo.DeclaringType != type || methodInfo.IsGenericMethod || methodInfo.IsGenericMethodDefinition)
					{
						continue;
					}
					IEnumerable<KeyValuePair<OpCode, object>> enumerable = PatchProcessor.ReadMethodBody((MethodBase)methodInfo);
					bool flag = false;
					foreach (KeyValuePair<OpCode, object> item in enumerable)
					{
						if (!(item.Key == OpCodes.Ldfld) || !(item.Value is FieldInfo fieldInfo))
						{
							continue;
						}
						foreach (KeyValuePair<string, MethodInfo> patch in AdvancedCompany.Game.Manager.Patches)
						{
							if (fieldInfo.DeclaringType.FullName + "." + fieldInfo.Name == patch.Key)
							{
								flag = true;
								break;
							}
						}
					}
					if (flag)
					{
						try
						{
							Plugin.Log.LogDebug((object)("Patching " + methodInfo.DeclaringType.FullName + "->" + methodInfo.Name));
							val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null);
							Plugin.Log.LogDebug((object)("Patched " + methodInfo.DeclaringType.FullName + "->" + methodInfo.Name));
						}
						catch (Exception ex)
						{
							Plugin.Log.LogError((object)("Error while transpiling " + methodInfo.DeclaringType.FullName + "->" + methodInfo.Name + ":"));
							Plugin.Log.LogError((object)ex);
						}
					}
				}
			}
			catch (FileNotFoundException ex2)
			{
				Plugin.Log.LogWarning((object)"Likely some soft dependency of another mod is missing (THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR!):");
				Plugin.Log.LogWarning((object)ex2);
			}
			catch (TypeLoadException ex3)
			{
				Plugin.Log.LogWarning((object)"Likely some soft dependency of another mod is missing (THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR! THIS IS MOST LIKELY A NON ERROR!):");
				Plugin.Log.LogWarning((object)ex3);
			}
			catch (Exception ex4)
			{
				Plugin.Log.LogError((object)"Error while scanning types:");
				Plugin.Log.LogError((object)ex4);
			}
		}

		internal static void ApplyPatches()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			Harmony val = new Harmony("AdvancedCompany");
			foreach (KeyValuePair<Type, List<(string, MethodType)>> patch in Patches)
			{
				Plugin.Log.LogDebug((object)("Patching " + patch.Key));
				MethodInfo[] methods = patch.Key.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				foreach (var item in patch.Value)
				{
					MethodInfo[] array = methods;
					foreach (MethodInfo methodInfo in array)
					{
						if (methodInfo.Name == item.Item1)
						{
							HarmonyMethod val2 = new HarmonyMethod(typeof(FieldPatches).GetMethod("PatchFields", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy));
							val2.methodType = item.Item2;
							Plugin.Log.LogDebug((object)("Patching " + patch.Key.FullName + "->" + methodInfo.Name));
							val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null);
							Plugin.Log.LogDebug((object)("Patched " + patch.Key.FullName + "->" + methodInfo.Name));
						}
					}
				}
			}
		}

		private static IEnumerable<CodeInstruction> PatchFields(IEnumerable<CodeInstruction> instructions)
		{
			IEnumerable<CodeInstruction> source = AdvancedCompany.Game.Manager.PatchFields(instructions);
			return source.AsEnumerable();
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	internal class Flavour
	{
		private static Sprite Logo;

		private static Sprite PoweredByLogo;

		private static Image HeaderImage;

		private static Image LoadImage;

		private static Image HeaderPoweredByImage;

		private static Image LoadPoweredByImage;

		private static float PoweredByPhase = 0f;

		private static string RandomChars = "abcdefghjijkllmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

		private static bool FoundHeader = false;

		private static bool FoundLoad = false;

		private static string GenerateRandomString(int length = 8)
		{
			string text = "";
			Random random = new Random();
			for (int i = 0; i < length; i++)
			{
				text += RandomChars[random.Next(RandomChars.Length - 1)];
			}
			return text;
		}

		[HarmonyPatch(typeof(MenuManager), "Update")]
		[HarmonyPostfix]
		public static void Update()
		{
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_062c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_068a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)HeaderImage == (Object)null)
			{
				GameObject obj = GameObject.Find("HeaderImage");
				HeaderImage = ((obj != null) ? obj.GetComponent<Image>() : null) ?? null;
				if ((Object)(object)HeaderImage != (Object)null && (Object)(object)HeaderPoweredByImage == (Object)null)
				{
					GameObject val = new GameObject(GenerateRandomString(7));
					val.transform.parent = ((Component)HeaderImage).transform;
					val.SetActive((Object)(object)AdvancedCompany.Lib.Flavour.OverrideLogo != (Object)null);
					RectTransform val2 = val.AddComponent<RectTransform>();
					val2.pivot = new Vector2(0.5f, 0.5f);
					val2.anchorMax = new Vector2(1f, 1f);
					val2.anchorMin = new Vector2(1f, 1f);
					float num = 0.4f;
					val2.sizeDelta = new Vector2(545f * num, 125f * num);
					val2.anchoredPosition = new Vector2(38f, -32f);
					HeaderPoweredByImage = val.AddComponent<Image>();
					HeaderPoweredByImage.sprite = PoweredByLogo;
					FoundHeader = true;
				}
			}
			if ((Object)(object)LoadImage == (Object)null)
			{
				GameObject val3 = GameObject.Find("MenuContainer");
				for (int i = 0; i < val3.transform.childCount; i++)
				{
					Transform child = val3.transform.GetChild(i);
					if (!(((Object)child).name == "LoadingScreen"))
					{
						continue;
					}
					for (int j = 0; j < ((Component)child).transform.childCount; j++)
					{
						Transform child2 = ((Component)child).transform.GetChild(j);
						if (((Object)child2).name == "Image")
						{
							LoadImage = ((Component)child2).GetComponent<Image>();
						}
					}
					break;
				}
				if ((Object)(object)LoadImage != (Object)null && (Object)(object)LoadPoweredByImage == (Object)null)
				{
					GameObject val4 = new GameObject(GenerateRandomString(9));
					val4.transform.parent = ((Component)LoadImage).transform;
					val4.SetActive((Object)(object)AdvancedCompany.Lib.Flavour.OverrideLogo != (Object)null);
					RectTransform val5 = val4.AddComponent<RectTransform>();
					val5.pivot = new Vector2(0.5f, 0.5f);
					val5.anchorMax = new Vector2(1f, 1f);
					val5.anchorMin = new Vector2(1f, 1f);
					float num2 = 0.4f;
					val5.sizeDelta = new Vector2(545f * num2, 125f * num2);
					val5.anchoredPosition = new Vector2(38f, -32f);
					LoadPoweredByImage = val4.AddComponent<Image>();
					LoadPoweredByImage.sprite = PoweredByLogo;
					FoundLoad = true;
				}
			}
			if (((Object)(object)LoadImage == (Object)null && FoundLoad) || ((Object)(object)HeaderImage == (Object)null && FoundHeader))
			{
				Plugin.Cripple = true;
			}
			bool flag = (Object)(object)AdvancedCompany.Lib.Flavour.OverrideLogo != (Object)null;
			if (flag && (Object)(object)LoadPoweredByImage != (Object)null && !((Component)LoadPoweredByImage).gameObject.activeSelf)
			{
				((Component)LoadPoweredByImage).gameObject.SetActive(true);
			}
			if (flag && (Object)(object)HeaderPoweredByImage != (Object)null && !((Component)HeaderPoweredByImage).gameObject.activeSelf)
			{
				((Component)HeaderPoweredByImage).gameObject.SetActive(true);
			}
			Sprite val6 = (((Object)(object)AdvancedCompany.Lib.Flavour.OverrideLogo != (Object)null) ? AdvancedCompany.Lib.Flavour.OverrideLogo : Logo);
			if ((Object)(object)HeaderImage != (Object)null && (Object)(object)HeaderImage.sprite != (Object)(object)val6)
			{
				HeaderImage.sprite = val6;
			}
			if ((Object)(object)LoadImage != (Object)null && (Object)(object)LoadImage.sprite != (Object)(object)Logo)
			{
				LoadImage.sprite = val6;
			}
			PoweredByPhase += Time.deltaTime;
			float num3 = (Mathf.Sin(PoweredByPhase * MathF.PI * 1.5f) + 1f) / 16f + 0.5f;
			float num4 = (Mathf.Cos(PoweredByPhase * MathF.PI / 2f) + 1.5f - 0.25f) * 0.02f - 0.01f;
			if ((Object)(object)HeaderPoweredByImage != (Object)null)
			{
				((Component)HeaderPoweredByImage).transform.rotation = Quaternion.Euler(0f, 0f, num4 * 360f);
				((Component)HeaderPoweredByImage).transform.localScale = new Vector3(num3, num3, num3);
				((Behaviour)HeaderPoweredByImage).enabled = true;
				RectTransform component = ((Component)HeaderPoweredByImage).GetComponent<RectTransform>();
				component.pivot = new Vector2(0.5f, 0.5f);
				component.anchorMax = new Vector2(1f, 1f);
				component.anchorMin = new Vector2(1f, 1f);
				float num5 = 0.4f;
				component.sizeDelta = new Vector2(545f * num5, 125f * num5);
				component.anchoredPosition = new Vector2(38f, -32f);
				if ((Object)(object)((Component)HeaderPoweredByImage).transform.parent != (Object)(object)((Component)HeaderImage).transform)
				{
					((Component)HeaderPoweredByImage).transform.parent = ((Component)HeaderImage).transform;
				}
			}
			else if (FoundHeader)
			{
				Plugin.Cripple = true;
			}
			if ((Object)(object)LoadPoweredByImage != (Object)null)
			{
				((Component)LoadPoweredByImage).transform.rotation = Quaternion.Euler(0f, 0f, num4 * 360f);
				((Component)LoadPoweredByImage).transform.localScale = new Vector3(num3, num3, num3);
				((Behaviour)LoadPoweredByImage).enabled = true;
				RectTransform component2 = ((Component)LoadPoweredByImage).GetComponent<RectTransform>();
				component2.pivot = new Vector2(0.5f, 0.5f);
				component2.anchorMax = new Vector2(1f, 1f);
				component2.anchorMin = new Vector2(1f, 1f);
				float num6 = 0.4f;
				component2.sizeDelta = new Vector2(545f * num6, 125f * num6);
				component2.anchoredPosition = new Vector2(38f, -32f);
				if ((Object)(object)((Component)LoadPoweredByImage).transform.parent != (Object)(object)((Component)LoadImage).transform)
				{
					((Component)LoadPoweredByImage).transform.parent = ((Component)LoadImage).transform;
				}
			}
			else if (FoundLoad)
			{
				Plugin.Cripple = true;
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			Logo = assets.LoadAsset<Sprite>("Assets/Icons/Logo.png");
			PoweredByLogo = assets.LoadAsset<Sprite>("Assets/Icons/SmallLogo.png");
		}
	}
	[HarmonyPatch]
	internal class GameNetworkManager
	{
		public static string KickReason;

		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientConnectedCallback")]
		[HarmonyPrefix]
		private static void Singleton_OnClientConnectedCallback(GameNetworkManager __instance, ulong clientId)
		{
			AdvancedCompany.Network.Manager.NetworkManager_OnClientConnectedCallback(clientId);
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void Start(GameNetworkManager __instance)
		{
			AdvancedCompany.Network.Manager.Initialize();
			AdvancedCompany.Network.Manager.OnKicked = (AdvancedCompany.Network.Manager.Kicked)Delegate.Combine(AdvancedCompany.Network.Manager.OnKicked, (AdvancedCompany.Network.Manager.Kicked)delegate(string reason)
			{
				KickReason = reason;
			});
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
		[HarmonyPostfix]
		public static void SaveItemsInShip(GameNetworkManager __instance)
		{
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		private static void Disconnect(GameNetworkManager __instance)
		{
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SaveGame")]
		[HarmonyPrefix]
		private static void Save(GameNetworkManager __instance)
		{
			try
			{
				AdvancedCompany.Network.Manager.Lobby.Player().SaveLocal();
				if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.Save(__instance.currentSaveFileName);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "ResetUnlockablesListValues")]
		[HarmonyPrefix]
		private static bool ResetClone(GameNetworkManager __instance)
		{
			//IL_0086: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)StartOfRound.Instance != (Object)null))
			{
				return true;
			}
			List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
			for (int i = 0; i < unlockables.Count; i++)
			{
				if (!ServerConfiguration.Instance.General.SaveSuitsAfterDeath || unlockables[i].unlockableType != 0)
				{
					unlockables[i].hasBeenUnlockedByPlayer = false;
				}
				if (unlockables[i].unlockableType == 1)
				{
					unlockables[i].placedPosition = Vector3.zero;
					unlockables[i].placedRotation = Vector3.zero;
					unlockables[i].hasBeenMoved = false;
					unlockables[i].inStorage = false;
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal class GrabbableObject
	{
		private static IEnumerable<CodeInstruction> PatchUpdate(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching GrabbableObject->Update...");
			PropertyInfo property = typeof(Perks).GetProperty("ExtraBatteryMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single batteryUsage")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ExtraBattery", list, i + 1);
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched GrabbableObject->Update...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(GrabbableObject), "Update")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase method)
		{
			if (method.Name == "Update")
			{
				return PatchUpdate(instructions);
			}
			return instructions;
		}
	}
	[HarmonyPatch]
	internal class HUDManager
	{
		[HarmonyPatch(typeof(HUDManager), "MeetsScanNodeRequirements")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchMeetsScanNodeRequirements(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching HUDManager->MeetsScanNodeRequirements...");
			PropertyInfo property = typeof(Perks).GetProperty("ScanDistanceMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Int32 maxRange")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ScanDistance", list, i + 2);
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched HUDManager->MeetsScanNodeRequirements...");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	[Requires(typeof(ClientConfiguration))]
	[Bootable]
	public class InventoryPatches
	{
		public enum InventoryType
		{
			INVENTORY,
			HELMET,
			BODY,
			SHOES
		}

		private static InputAction InventorySlot1Action;

		private static InputAction InventorySlot2Action;

		private static InputAction InventorySlot3Action;

		private static InputAction InventorySlot4Action;

		private static InputAction InventorySlot5Action;

		private static InputAction InventorySlot6Action;

		private static InputAction InventorySlot7Action;

		private static InputAction InventorySlot8Action;

		private static InputAction InventorySlot9Action;

		private static InputAction InventorySlot10Action;

		private static InputAction EquipmentAction;

		private static InputAction FlashlightAction;

		private static InputAction NightVisionAction;

		private static InputAction CommunicationAction;

		public const int MAX_INVENTORY = 13;

		public static Image HelmetImage;

		public static Image BodyImage;

		public static Image ShoesImage;

		internal static bool InEquipmentSlots = false;

		internal static int PreviousInventorySlot = 0;

		internal static float EquipmentPhase = 0f;

		private static FieldInfo IsSendingItemRPCField = typeof(GrabbableObject).GetField("isSendingItemRPC", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static MethodInfo ActivateItemServerRpcMethod = typeof(GrabbableObject).GetMethod("ActivateItemServerRpc", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo FlashlightPreviousPlayerHeldBy = typeof(FlashlightItem).GetField("previousPlayerHeldBy", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static int OwnItemSlotResult;

		public static FieldInfo TimeSinceSwitchingSlotsField = AccessTools.Field(typeof(PlayerControllerB), "timeSinceSwitchingSlots");

		public static FieldInfo ThrowingObjectField = AccessTools.Field(typeof(PlayerControllerB), "throwingObject");

		public static MethodInfo NextItemMethod = AccessTools.Method(typeof(PlayerControllerB), "NextItemSlot", (Type[])null, (Type[])null);

		public static MethodInfo SwitchToItemSlotMethod = AccessTools.Method(typeof(PlayerControllerB), "SwitchToItemSlot", (Type[])null, (Type[])null);

		private static GameObject EnergyPrefab;

		private static AnimationClip EquipmentFrameAnimation;

		private static AnimationClip EquipmentFrameEnlargeAnimation;

		private static Sprite HelmetIcon;

		private static Sprite BodyIcon;

		private static Sprite ShoesIcon;

		private static GameObject[] EnergyBars = (GameObject[])(object)new GameObject[13];

		private static RectTransform[] EnergyInnerBars = (RectTransform[])(object)new RectTransform[13];

		private static GameObject ScaleCompensator;

		private static Transform Inventory;

		private static Transform EquipmentSlots;

		private static GridLayoutGroup InventoryGridLayout;

		private static GridLayoutGroup EquipmentGridLayout;

		private static float PreviousAnchorMax = 0f;

		private static float PreviousWidth = 0f;

		private static bool UpdateNextFrame = false;

		private static FieldInfo CurrentlyGrabbingObjectField = typeof(PlayerControllerB).GetField("currentlyGrabbingObject", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static GrabbableObject HoveringObject;

		public static bool HeadSlotAvailable
		{
			get
			{
				if (ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					return false;
				}
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName("Vision enhancer");
				int result;
				if (byItemName == null || !byItemName.Active)
				{
					LobbyConfiguration.ItemConfig byItemName2 = ServerConfiguration.Instance.Items.GetByItemName("Helmet lamp");
					if (byItemName2 == null || !byItemName2.Active)
					{
						result = ((ServerConfiguration.Instance.Items.GetByItemName("Headset")?.Active ?? false) ? 1 : 0);
						goto IL_007f;
					}
				}
				result = 1;
				goto IL_007f;
				IL_007f:
				return (byte)result != 0;
			}
		}

		public static bool BodySlotAvailable
		{
			get
			{
				if (ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					return false;
				}
				return ServerConfiguration.Instance.Items.GetByItemName("Bulletproof vest")?.Active ?? false;
			}
		}

		public static bool FeetSlotAvailable
		{
			get
			{
				if (ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					return false;
				}
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName("Rocket boots");
				int result;
				if (byItemName == null || !byItemName.Active)
				{
					LobbyConfiguration.ItemConfig byItemName2 = ServerConfiguration.Instance.Items.GetByItemName("Flippers");
					if (byItemName2 == null || !byItemName2.Active)
					{
						result = ((ServerConfiguration.Instance.Items.GetByScrapName("Light shoes")?.Active ?? false) ? 1 : 0);
						goto IL_007f;
					}
				}
				result = 1;
				goto IL_007f;
				IL_007f:
				return (byte)result != 0;
			}
		}

		public static void Boot()
		{
			ClientConfiguration.Keybinds.InventorySlot1.performed += delegate
			{
				ChangeToInventorySlot(0);
			};
			ClientConfiguration.Keybinds.InventorySlot2.performed += delegate
			{
				ChangeToInventorySlot(1);
			};
			ClientConfiguration.Keybinds.InventorySlot3.performed += delegate
			{
				ChangeToInventorySlot(2);
			};
			ClientConfiguration.Keybinds.InventorySlot4.performed += delegate
			{
				ChangeToInventorySlot(3);
			};
			ClientConfiguration.Keybinds.InventorySlot5.performed += delegate
			{
				ChangeToInventorySlot(4);
			};
			ClientConfiguration.Keybinds.InventorySlot6.performed += delegate
			{
				ChangeToInventorySlot(5);
			};
			ClientConfiguration.Keybinds.InventorySlot7.performed += delegate
			{
				ChangeToInventorySlot(6);
			};
			ClientConfiguration.Keybinds.InventorySlot8.performed += delegate
			{
				ChangeToInventorySlot(7);
			};
			ClientConfiguration.Keybinds.InventorySlot9.performed += delegate
			{
				ChangeToInventorySlot(8);
			};
			ClientConfiguration.Keybinds.InventorySlot10.performed += delegate
			{
				ChangeToInventorySlot(9);
			};
			ClientConfiguration.Keybinds.Equipment.started += delegate
			{
				ToggleEquipment(active: true);
			};
			ClientConfiguration.Keybinds.Equipment.canceled += delegate
			{
				ToggleEquipment(active: false);
			};
			ClientConfiguration.Keybinds.Flashlight.performed += delegate
			{
				ToggleFlashlight();
			};
			ClientConfiguration.Keybinds.Communications.started += delegate
			{
				ToggleComms(on: true);
			};
			ClientConfiguration.Keybinds.Communications.canceled += delegate
			{
				ToggleComms(on: false);
			};
			AdvancedCompany.Network.Manager.AddListener(delegate(SwitchItem msg)
			{
				if (ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					return;
				}
				try
				{
					PlayerControllerB[] allPlayerScripts2 = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val7 in allPlayerScripts2)
					{
						if ((int)val7.playerClientId == msg.PlayerNum)
						{
							val7.SwitchToItemSlot(msg.Slot, (GrabbableObject)null);
							break;
						}
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)ex2);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(ChangeItemSlot msg)
			{
				if (ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					return;
				}
				try
				{
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val4 in allPlayerScripts)
					{
						if ((val4.isPlayerControlled || val4.isHostPlayerObject) && (int)val4.playerClientId == msg.PlayerNum)
						{
							if ((Object)(object)val4.ItemSlots[msg.FromSlot] != (Object)null)
							{
								GrabbableObject val5 = val4.ItemSlots[msg.FromSlot];
								GrabbableObject val6 = val4.ItemSlots[msg.ToSlot];
								if ((Object)(object)val4 == (Object)(object)GameNetworkManager.Instance.localPlayerController)
								{
									Sprite sprite = HUDManager.Instance.itemSlotIcons[msg.ToSlot].sprite;
									bool enabled = ((Behaviour)HUDManager.Instance.itemSlotIcons[msg.ToSlot]).enabled;
									HUDManager.Instance.itemSlotIcons[msg.ToSlot].sprite = HUDManager.Instance.itemSlotIcons[msg.FromSlot].sprite;
									((Behaviour)HUDManager.Instance.itemSlotIcons[msg.ToSlot]).enabled = ((Behaviour)HUDManager.Instance.itemSlotIcons[msg.FromSlot]).enabled;
									HUDManager.Instance.itemSlotIcons[msg.FromSlot].sprite = sprite;
									((Behaviour)HUDManager.Instance.itemSlotIcons[msg.FromSlot]).enabled = enabled;
								}
								val4.ItemSlots[msg.FromSlot] = val6;
								val4.ItemSlots[msg.ToSlot] = val5;
								SwitchToItemSlotMethod.Invoke(val4, new object[2] { val4.currentItemSlot, null });
							}
							break;
						}
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)ex);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(UseFlashlight msg)
			{
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				if (!ServerConfiguration.Instance.General.DeactivateHotbar)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(msg.PlayerNum);
					if (player != null && !player.Controller.inSpecialInteractAnimation)
					{
						GrabbableObject val = player.Controller.ItemSlots[msg.Slot];
						if ((Object)(object)val != (Object)null)
						{
							FlashlightItem val2 = (FlashlightItem)(object)((val is FlashlightItem) ? val : null);
							if (val2 != null)
							{
								val2.flashlightAudio.PlayOneShot(val2.flashlightClips[Random.Range(0, val2.flashlightClips.Length)]);
								RoundManager.Instance.PlayAudibleNoise(((Component)val2).transform.position, 7f, 0.4f, 0, ((GrabbableObject)val2).isInElevator && StartOfRound.Instance.hangarDoorsClosed, 0);
								if (val2.flashlightInterferenceLevel < 2)
								{
									if (!((GrabbableObject)val2).isBeingUsed)
									{
										for (int i = 0; i < player.Controller.ItemSlots.Length; i++)
										{
											if (i != msg.Slot && (Object)(object)player.Controller.ItemSlots[i] != (Object)null)
											{
												GrabbableObject obj2 = player.Controller.ItemSlots[i];
												FlashlightItem val3 = (FlashlightItem)(object)((obj2 is FlashlightItem) ? obj2 : null);
												if (val3 != null)
												{
													if (((NetworkBehaviour)val3).IsOwner && (Object)(object)((GrabbableObject)val3).playerHeldBy != (Object)null)
													{
														((GrabbableObject)val3).playerHeldBy.ChangeHelmetLight(val3.flashlightTypeID, false);
													}
													if (((GrabbableObject)val3).isBeingUsed)
													{
														((GrabbableObject)val3).isBeingUsed = false;
													}
													UpdateFlashlightState(val3, !((GrabbableObject)val2).isPocketed);
												}
											}
										}
									}
									if (!((GrabbableObject)val2).isBeingUsed && ((GrabbableObject)val2).insertedBattery != null && ((GrabbableObject)val2).insertedBattery.charge > 0f)
									{
										((GrabbableObject)val2).isBeingUsed = true;
									}
									else
									{
										((GrabbableObject)val2).isBeingUsed = false;
									}
									UpdateFlashlightState(val2, player.Controller.currentItemSlot == msg.Slot);
								}
							}
						}
					}
				}
			});
		}

		internal static void ToggleEquipment(bool active)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar || (Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.localPlayerController == (Object)null)
			{
				return;
			}
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (active && (HeadSlotAvailable || BodySlotAvailable || FeetSlotAvailable))
			{
				PreviousInventorySlot = localPlayerController.currentItemSlot;
				if (HeadSlotAvailable)
				{
					SwitchItem(localPlayerController, 10);
				}
				else if (BodySlotAvailable)
				{
					SwitchItem(localPlayerController, 11);
				}
				else if (FeetSlotAvailable)
				{
					SwitchItem(localPlayerController, 12);
				}
				InEquipmentSlots = true;
			}
			else if (InEquipmentSlots)
			{
				SwitchItem(localPlayerController, PreviousInventorySlot);
				InEquipmentSlots = false;
			}
		}

		internal static void UpdateFlashlightState(FlashlightItem flashlight, bool isHeld)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(((GrabbableObject)flashlight).playerHeldBy);
			if (player == null)
			{
				return;
			}
			if (isHeld)
			{
				flashlight.previousPlayerHeldBy = ((GrabbableObject)flashlight).playerHeldBy;
				((GrabbableObject)flashlight).playerHeldBy.ChangeHelmetLight(flashlight.flashlightTypeID, true);
				((Behaviour)((GrabbableObject)flashlight).playerHeldBy.helmetLight).enabled = false;
				flashlight.usingPlayerHelmetLight = false;
				if (!((NetworkBehaviour)flashlight).IsOwner)
				{
					((GrabbableObject)flashlight).playerHeldBy.ChangeHelmetLight(flashlight.flashlightTypeID, ((GrabbableObject)flashlight).isBeingUsed);
					((Behaviour)flashlight.flashlightBulb).enabled = false;
					((Behaviour)flashlight.flashlightBulbGlow).enabled = false;
				}
				else
				{
					((Behaviour)flashlight.flashlightBulb).enabled = ((GrabbableObject)flashlight).isBeingUsed;
					((Behaviour)flashlight.flashlightBulbGlow).enabled = ((GrabbableObject)flashlight).isBeingUsed;
				}
				if (flashlight.changeMaterial)
				{
					Material[] sharedMaterials = ((Renderer)flashlight.flashlightMesh).sharedMaterials;
					if (((GrabbableObject)flashlight).isBeingUsed)
					{
						sharedMaterials[1] = flashlight.bulbLight;
					}
					else
					{
						sharedMaterials[1] = flashlight.bulbDark;
					}
					((Renderer)flashlight.flashlightMesh).sharedMaterials = sharedMaterials;
				}
			}
			else
			{
				((Behaviour)flashlight.flashlightBulb).enabled = false;
				((Behaviour)flashlight.flashlightBulbGlow).enabled = false;
				((GrabbableObject)flashlight).playerHeldBy.ChangeHelmetLight(flashlight.flashlightTypeID, true);
				if (!((NetworkBehaviour)flashlight).IsOwner)
				{
					((GrabbableObject)flashlight).playerHeldBy.ChangeHelmetLight(flashlight.flashlightTypeID, ((GrabbableObject)flashlight).isBeingUsed);
				}
				else if (((GrabbableObject)flashlight).isBeingUsed)
				{
					((Behaviour)((GrabbableObject)flashlight).playerHeldBy.helmetLight).enabled = true;
					((GrabbableObject)flashlight).playerHeldBy.pocketedFlashlight = (GrabbableObject)(object)flashlight;
					flashlight.usingPlayerHelmetLight = true;
				}
				else
				{
					flashlight.usingPlayerHelmetLight = false;
					((Behaviour)((GrabbableObject)flashlight).playerHeldBy.helmetLight).enabled = false;
					if (flashlight.changeMaterial)
					{
						Material[] sharedMaterials2 = ((Renderer)flashlight.flashlightMesh).sharedMaterials;
						sharedMaterials2[1] = flashlight.bulbDark;
						((Renderer)flashlight.flashlightMesh).sharedMaterials = sharedMaterials2;
					}
				}
			}
			flashlight.SwitchFlashlight(((GrabbableObject)flashlight).isBeingUsed);
		}

		public static void ChangeToInventorySlot(int slot)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar || !((Object)(object)GameNetworkManager.Instance != (Object)null) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(localPlayerController);
			if (!player.LockInventory && !localPlayerController.inTerminalMenu && !localPlayerController.isPlayerDead)
			{
				int num = Perks.InventorySlotsOf(localPlayerController);
				if (slot < num)
				{
					SwitchItem(localPlayerController, slot);
				}
			}
		}

		public static void ToggleComms(bool on)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar || !((Object)(object)GameNetworkManager.Instance != (Object)null) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!localPlayerController.inTerminalMenu && !localPlayerController.isPlayerDead)
			{
				IEquipmentCommunication equipmentCommunication = null;
				if (localPlayerController.ItemSlots[10] is IEquipmentCommunication equipmentCommunication2)
				{
					equipmentCommunication = equipmentCommunication2;
				}
				if (localPlayerController.ItemSlots[11] is IEquipmentCommunication equipmentCommunication3)
				{
					equipmentCommunication = equipmentCommunication3;
				}
				if (localPlayerController.ItemSlots[12] is IEquipmentCommunication equipmentCommunication4)
				{
					equipmentCommunication = equipmentCommunication4;
				}
				equipmentCommunication?.SwitchTalking(AdvancedCompany.Game.Player.GetPlayer(localPlayerController), on);
			}
		}

		public static void ToggleNightVision()
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar || !((Object)(object)GameNetworkManager.Instance != (Object)null) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (!localPlayerController.inTerminalMenu && !localPlayerController.isPlayerDead)
			{
				IEquipmentFlashlight equipmentFlashlight = null;
				if (localPlayerController.ItemSlots[10] is IEquipmentFlashlight equipmentFlashlight2)
				{
					equipmentFlashlight = equipmentFlashlight2;
				}
				if (localPlayerController.ItemSlots[11] is IEquipmentFlashlight equipmentFlashlight3)
				{
					equipmentFlashlight = equipmentFlashlight3;
				}
				if (localPlayerController.ItemSlots[12] is IEquipmentFlashlight equipmentFlashlight4)
				{
					equipmentFlashlight = equipmentFlashlight4;
				}
				equipmentFlashlight?.SwitchFlashlight(AdvancedCompany.Game.Player.GetPlayer(localPlayerController), !equipmentFlashlight.IsUsed());
			}
		}

		public static void ToggleFlashlight(bool ignoreHead = false)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar || !((Object)(object)GameNetworkManager.Instance != (Object)null) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (localPlayerController.inTerminalMenu || localPlayerController.isPlayerDead)
			{
				return;
			}
			FlashlightItem val = null;
			float num = 0f;
			bool flag = false;
			IEquipmentFlashlight equipmentFlashlight = null;
			if (!ignoreHead)
			{
				if (localPlayerController.ItemSlots[10] is IEquipmentFlashlight equipmentFlashlight2 && equipmentFlashlight2.CanBeUsed())
				{
					equipmentFlashlight = equipmentFlashlight2;
				}
				if (localPlayerController.ItemSlots[11] is IEquipmentFlashlight equipmentFlashlight3 && equipmentFlashlight3.CanBeUsed())
				{
					equipmentFlashlight = equipmentFlashlight3;
				}
				if (localPlayerController.ItemSlots[12] is IEquipmentFlashlight equipmentFlashlight4 && equipmentFlashlight4.CanBeUsed())
				{
					equipmentFlashlight = equipmentFlashlight4;
				}
			}
			if (equipmentFlashlight != null)
			{
				equipmentFlashlight.SwitchFlashlight(AdvancedCompany.Game.Player.GetPlayer(localPlayerController), !equipmentFlashlight.IsUsed());
				for (int i = 0; i < 7; i++)
				{
					GrabbableObject obj = localPlayerController.ItemSlots[i];
					FlashlightItem val2 = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
					if (val2 != null && ((GrabbableObject)val2).isBeingUsed)
					{
						UseFlashlight(localPlayerController, val2);
					}
				}
				return;
			}
			for (int j = 0; j < localPlayerController.ItemSlots.Length; j++)
			{
				GrabbableObject obj2 = localPlayerController.ItemSlots[j];
				FlashlightItem val3 = (FlashlightItem)(object)((obj2 is FlashlightItem) ? obj2 : null);
				if (val3 == null)
				{
					continue;
				}
				bool flag2 = ((GrabbableObject)val3).itemProperties.itemName.StartsWith("pro", StringComparison.OrdinalIgnoreCase);
				bool flag3 = ((GrabbableObject)val3).itemProperties.itemName.StartsWith("flash", StringComparison.OrdinalIgnoreCase);
				if (flag2 || flag3)
				{
					if (((GrabbableObject)val3).isBeingUsed)
					{
						UseFlashlight(localPlayerController, val3);
						val = null;
						break;
					}
					if (((GrabbableObject)val3).insertedBattery != null && ((GrabbableObject)val3).insertedBattery.charge > 0f && (((GrabbableObject)val3).insertedBattery.charge > num || (flag2 && !flag)))
					{
						val = val3;
						flag = flag2;
						num = ((GrabbableObject)val3).insertedBattery.charge;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				UseFlashlight(localPlayerController, val);
			}
		}

		private static void UseFlashlightOnClient(FlashlightItem flashlight, bool buttonDown)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			if (!((NetworkBehaviour)flashlight).IsOwner)
			{
				Debug.Log((object)"Can't use item; not owner");
			}
			else if (!((GrabbableObject)flashlight).RequireCooldown() && ((GrabbableObject)flashlight).UseItemBatteries())
			{
				if (((GrabbableObject)flashlight).itemProperties.syncUseFunction)
				{
					IsSendingItemRPCField.SetValue(flashlight, (int)IsSendingItemRPCField.GetValue(flashlight) + 1);
					ActivateItemServerRpcMethod.Invoke(flashlight, new object[2]
					{
						((GrabbableObject)flashlight).isBeingUsed,
						buttonDown
					});
				}
				((GrabbableObject)flashlight).ItemActivate(((GrabbableObject)flashlight).isBeingUsed, buttonDown);
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "UseItemOnClient")]
		[HarmonyPrefix]
		public static bool UseItemOnClient(GrabbableObject __instance)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			FlashlightItem val = (FlashlightItem)(object)((__instance is FlashlightItem) ? __instance : null);
			if (val != null)
			{
				int num = -1;
				if (((GrabbableObject)val).insertedBattery != null && ((GrabbableObject)val).insertedBattery.charge > 0f)
				{
					for (int i = 0; i < __instance.playerHeldBy.ItemSlots.Length; i++)
					{
						if ((Object)(object)__instance.playerHeldBy.ItemSlots[i] == (Object)(object)__instance)
						{
							num = i;
						}
					}
					if (num > -1)
					{
						AdvancedCompany.Network.Manager.Send(new UseFlashlight
						{
							PlayerNum = (int)__instance.playerHeldBy.playerClientId,
							Slot = num
						}, 0uL);
						return false;
					}
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(FlashlightItem), "SwitchFlashlight")]
		[HarmonyPrefix]
		public static bool SwitchFlashlight(bool on)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(FlashlightItem), "UseUpBatteries")]
		[HarmonyPrefix]
		public static void UseUpBatteries(FlashlightItem __instance)
		{
			if (!ServerConfiguration.Instance.General.DeactivateHotbar && (Object)(object)((GrabbableObject)__instance).playerHeldBy != (Object)null && (Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				AdvancedCompany.Network.Manager.Send(new UseFlashlight
				{
					PlayerNum = (int)((GrabbableObject)__instance).playerHeldBy.playerClientId,
					Slot = GrabbableObjectAdditions.GetInventoryPosition((GrabbableObject)(object)__instance)
				}, 0uL);
			}
		}

		[HarmonyPatch(typeof(FlashlightItem), "DiscardItem")]
		[HarmonyPrefix]
		public static bool DiscardItem(FlashlightItem __instance)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			if ((Object)(object)__instance.previousPlayerHeldBy != (Object)null)
			{
				if (((GrabbableObject)__instance).isBeingUsed)
				{
					((Behaviour)__instance.previousPlayerHeldBy.helmetLight).enabled = false;
				}
				((Behaviour)__instance.flashlightBulb).enabled = ((GrabbableObject)__instance).isBeingUsed;
				((Behaviour)__instance.flashlightBulbGlow).enabled = ((GrabbableObject)__instance).isBeingUsed;
			}
			IntPtr functionPointer = AccessTools.Method(typeof(GrabbableObject), "DiscardItem", (Type[])null, (Type[])null).MethodHandle.GetFunctionPointer();
			((Action)Activator.CreateInstance(typeof(Action), __instance, functionPointer))();
			return false;
		}

		[HarmonyPatch(typeof(FlashlightItem), "EquipItem")]
		[HarmonyPrefix]
		public static bool FlashlightEquipItem(FlashlightItem __instance)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			FlashlightPreviousPlayerHeldBy.SetValue(__instance, ((GrabbableObject)__instance).playerHeldBy);
			PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
			bool flag = false;
			for (int i = 0; i < playerHeldBy.ItemSlots.Length; i++)
			{
				GrabbableObject obj = playerHeldBy.ItemSlots[i];
				FlashlightItem val = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
				if (val != null && (Object)(object)val != (Object)(object)__instance && ((GrabbableObject)val).isBeingUsed)
				{
					flag = true;
					((GrabbableObject)__instance).isBeingUsed = false;
					((Behaviour)__instance.flashlightBulb).enabled = false;
					((Behaviour)__instance.flashlightBulbGlow).enabled = false;
					if (__instance.changeMaterial)
					{
						Material[] sharedMaterials = ((Renderer)__instance.flashlightMesh).sharedMaterials;
						sharedMaterials[1] = __instance.bulbDark;
						((Renderer)__instance.flashlightMesh).sharedMaterials = sharedMaterials;
					}
					break;
				}
			}
			if (!flag)
			{
				__instance.usingPlayerHelmetLight = false;
				((Behaviour)((GrabbableObject)__instance).playerHeldBy.helmetLight).enabled = false;
				if (((GrabbableObject)__instance).isBeingUsed)
				{
					UpdateFlashlightState(__instance, isHeld: true);
				}
			}
			IntPtr functionPointer = AccessTools.Method(typeof(GrabbableObject), "EquipItem", (Type[])null, (Type[])null).MethodHandle.GetFunctionPointer();
			((Action)Activator.CreateInstance(typeof(Action), __instance, functionPointer))();
			return false;
		}

		[HarmonyPatch(typeof(FlashlightItem), "PocketItem")]
		[HarmonyPrefix]
		public static bool FlashlightPocketItem(FlashlightItem __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			if (((NetworkBehaviour)__instance).IsOwner)
			{
				PlayerControllerB val = (PlayerControllerB)FlashlightPreviousPlayerHeldBy.GetValue(__instance);
				((Behaviour)__instance.flashlightBulb).enabled = false;
				((Behaviour)__instance.flashlightBulbGlow).enabled = false;
				if (((GrabbableObject)__instance).isBeingUsed)
				{
					((Behaviour)val.helmetLight).enabled = true;
					val.pocketedFlashlight = (GrabbableObject)(object)__instance;
					__instance.usingPlayerHelmetLight = true;
					__instance.PocketFlashlightServerRpc(true);
				}
			}
			IntPtr functionPointer = AccessTools.Method(typeof(GrabbableObject), "PocketItem", (Type[])null, (Type[])null).MethodHandle.GetFunctionPointer();
			((Action)Activator.CreateInstance(typeof(Action), __instance, functionPointer))();
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "OnEnable")]
		[HarmonyPostfix]
		public static void OnEnable(PlayerControllerB __instance)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			try
			{
				if (__instance.ItemSlots.Length < 13)
				{
					GrabbableObject[] itemSlots = __instance.ItemSlots;
					GrabbableObject[] array = (GrabbableObject[])(object)new GrabbableObject[13];
					Array.Copy(itemSlots, array, itemSlots.Length);
					__instance.ItemSlots = array;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while changing inventory size");
				Plugin.Log.LogError((object)ex);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		public static void UpdatePre(PlayerControllerB __instance)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			try
			{
				if (!((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)__instance))
				{
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
		}

		private static void UseFlashlight(PlayerControllerB __instance, FlashlightItem flashlight)
		{
			if (!ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				((GrabbableObject)flashlight).UseItemOnClient(true);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "NextItemSlot")]
		[HarmonyPrefix]
		public static bool NextItemSlot(PlayerControllerB __instance, ref int __result, ref bool forward)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			int num = Perks.InventorySlotsOf(__instance);
			int currentItemSlot = __instance.currentItemSlot;
			if (InEquipmentSlots)
			{
				currentItemSlot = ((!forward) ? (currentItemSlot + 1) : (currentItemSlot - 1));
				if (currentItemSlot < 10)
				{
					currentItemSlot = 12;
				}
				if (currentItemSlot > 12)
				{
					currentItemSlot = 10;
				}
				if ((currentItemSlot != 10 || !HeadSlotAvailable) && (currentItemSlot != 11 || !BodySlotAvailable) && (currentItemSlot != 12 || !FeetSlotAvailable))
				{
					if (!forward)
					{
						if (currentItemSlot == 10 && !HeadSlotAvailable)
						{
							currentItemSlot++;
						}
						if (currentItemSlot == 11 && !BodySlotAvailable)
						{
							currentItemSlot++;
						}
						if (currentItemSlot == 12 && !FeetSlotAvailable)
						{
							currentItemSlot = (HeadSlotAvailable ? 10 : 11);
						}
					}
					else
					{
						if (currentItemSlot == 12 && !FeetSlotAvailable)
						{
							currentItemSlot--;
						}
						if (currentItemSlot == 11 && !BodySlotAvailable)
						{
							currentItemSlot--;
						}
						if (currentItemSlot == 10 && !HeadSlotAvailable)
						{
							currentItemSlot = (FeetSlotAvailable ? 12 : 11);
						}
					}
				}
			}
			else
			{
				currentItemSlot = ((!forward) ? (currentItemSlot - 1) : (currentItemSlot + 1));
				if (currentItemSlot >= num)
				{
					currentItemSlot = 0;
				}
				else if (currentItemSlot < 0)
				{
					currentItemSlot = num - 1;
				}
			}
			__result = currentItemSlot;
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ScrollMouse_performed")]
		[HarmonyBefore(new string[] { "ReservedItemSlotCore" })]
		[HarmonyPrefix]
		public static bool ScrollMouse_performed(PlayerControllerB __instance, CallbackContext context)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			try
			{
				if (Chainloader.PluginInfos.ContainsKey("FlipMods.ReservedItemSlotCore") && __instance.currentItemSlot >= 13)
				{
					return true;
				}
				if (!((CallbackContext)(ref context)).performed)
				{
					return false;
				}
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(__instance);
				if (player.LockInventory)
				{
					return false;
				}
				if (__instance.inTerminalMenu)
				{
					if (player.MobileTerminal != null && player.MobileTerminal.IsOpen)
					{
						float num = ((CallbackContext)(ref context)).ReadValue<float>();
						float num2 = num * 20f / player.MobileTerminal.ScrollRect.content.sizeDelta.y;
						ScrollRect scrollRect = player.MobileTerminal.ScrollRect;
						scrollRect.verticalNormalizedPosition += num2;
					}
					else
					{
						float num3 = ((CallbackContext)(ref context)).ReadValue<float>();
						Scrollbar terminalScrollVertical = __instance.terminalScrollVertical;
						terminalScrollVertical.value += num3 / 8f;
					}
				}
				else if (__instance.timeSinceSwitchingSlots >= 0.1f)
				{
					int slot = __instance.currentItemSlot;
					if (((CallbackContext)(ref context)).ReadValue<float>() > 0f)
					{
						slot = (int)NextItemMethod.Invoke(__instance, new object[1] { (!ClientConfiguration.Instance.Hotbar.InvertScroll) ? true : false });
					}
					else if (((CallbackContext)(ref context)).ReadValue<float>() < 0f)
					{
						slot = (int)NextItemMethod.Invoke(__instance, new object[1] { ClientConfiguration.Instance.Hotbar.InvertScroll ? true : false });
					}
					SwitchItem(__instance, slot);
				}
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
			return true;
		}

		public static bool SwitchItem(PlayerControllerB __instance, int slot)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			try
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(__instance);
				if (player.LockInventory)
				{
					return false;
				}
				if (((((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled && (!((NetworkBehaviour)__instance).IsServer || __instance.isHostPlayerObject)) || __instance.isTestingPlayer) && !((float)TimeSinceSwitchingSlotsField.GetValue(__instance) < 0.1f) && !__instance.isGrabbingObjectAnimation && !__instance.quickMenuManager.isMenuOpen && !__instance.inSpecialInteractAnimation && !(bool)ThrowingObjectField.GetValue(__instance) && !__instance.isTypingChat && !__instance.twoHanded && !__instance.activatingItem && !__instance.jetpackControls && !__instance.disablingJetpackControls)
				{
					ShipBuildModeManager.Instance.CancelBuildMode(true);
					__instance.playerBodyAnimator.SetBool("GrabValidated", false);
					TimeSinceSwitchingSlotsField.SetValue(__instance, 0f);
					AdvancedCompany.Network.Manager.Send(new SwitchItem
					{
						PlayerNum = (int)__instance.playerClientId,
						Slot = slot
					}, 0uL);
					if ((Object)(object)__instance.currentlyHeldObjectServer != (Object)null)
					{
						((Component)__instance.currentlyHeldObjectServer).gameObject.GetComponent<AudioSource>().PlayOneShot(__instance.currentlyHeldObjectServer.itemProperties.grabSFX, 0.6f);
					}
				}
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
			return true;
		}

		public static void LoadAssets(AssetBundle assets)
		{
			EnergyPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/Energy.prefab");
			EquipmentFrameAnimation = assets.LoadAsset<AnimationClip>("Assets/Icons/EquipmentSlot.anim");
			EquipmentFrameEnlargeAnimation = assets.LoadAsset<AnimationClip>("Assets/Icons/EquipmentSlotEnlarge.anim");
			HelmetIcon = assets.LoadAsset<Sprite>("Assets/Icons/Helmet.png");
			BodyIcon = assets.LoadAsset<Sprite>("Assets/Icons/Body.png");
			ShoesIcon = assets.LoadAsset<Sprite>("Assets/Icons/Shoes.png");
		}

		[HarmonyPatch(typeof(HUDManager), "OnEnable")]
		[HarmonyPostfix]
		public static void InitializeHotbar(HUDManager __instance)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar || __instance.itemSlotIcons.Length >= 13)
			{
				return;
			}
			Image[] array = (Image[])(object)new Image[13];
			Image[] array2 = (Image[])(object)new Image[13];
			Array.Copy(__instance.itemSlotIcons, array, __instance.itemSlotIcons.Length);
			Array.Copy(__instance.itemSlotIconFrames, array2, __instance.itemSlotIconFrames.Length);
			__instance.itemSlotIcons = array;
			__instance.itemSlotIconFrames = array2;
			GameObject val = new GameObject("EquipmentSlots");
			val.transform.parent = ((Component)array2[0]).transform.parent;
			val.transform.localScale = Vector3.one;
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMax = Vector2.op_Implicit(new Vector3(1f, 1f));
			val2.anchorMin = Vector2.op_Implicit(new Vector3(1f, 0f));
			val2.pivot = Vector2.op_Implicit(new Vector3(1f, 0f));
			val2.offsetMin = new Vector2(0f, 0f);
			val2.offsetMax = new Vector2(0f, 0f);
			val2.anchoredPosition3D = new Vector3(-10f, 0f, 0f);
			EquipmentSlots = val.transform;
			EquipmentGridLayout = val.AddComponent<GridLayoutGroup>();
			EquipmentGridLayout.constraint = (Constraint)1;
			EquipmentGridLayout.constraintCount = 1;
			((LayoutGroup)EquipmentGridLayout).childAlignment = (TextAnchor)8;
			EquipmentGridLayout.startAxis = (Axis)1;
			EquipmentGridLayout.startCorner = (Corner)2;
			EquipmentGridLayout.cellSize = new Vector2(80f, 80f);
			EquipmentGridLayout.spacing = new Vector2(0f, 10f);
			val.AddComponent<LayoutElement>().ignoreLayout = true;
			((Component)((Component)array2[0]).transform.parent).gameObject.SetActive(false);
			float y = ((Component)array2[0]).GetComponent<RectTransform>().anchoredPosition.y;
			for (int i = 0; i < 13; i++)
			{
				if ((Object)(object)array2[i] == (Object)null)
				{
					array2[i] = Object.Instantiate<GameObject>(((Component)array2[0]).gameObject, (i >= 10) ? EquipmentSlots : ((Component)array2[0]).transform.parent).GetComponent<Image>();
					array[i] = ((Component)((Component)array2[i]).transform.GetChild(0)).GetComponent<Image>();
				}
				((Object)array2[i]).name = "Slot" + i;
				((Object)array[i]).name = "Icon";
				((Graphic)array[i]).rectTransform.anchorMin = new Vector2(0f, 0f);
				((Graphic)array[i]).rectTransform.anchorMax = new Vector2(1f, 1f);
				((Transform)((Graphic)array2[i]).rectTransform).rotation = Quaternion.identity;
				((Graphic)array2[i]).rectTransform.anchorMax = new Vector2((i >= 10) ? 1f : 0f, 0f);
				((Graphic)array2[i]).rectTransform.anchorMin = new Vector2((i >= 10) ? 1f : 0f, 0f);
				((Component)array2[i]).transform.GetChild(0).rotation = Quaternion.identity;
				((Graphic)array2[i]).rectTransform.anchoredPosition = new Vector2(0f, 0f);
			}
			InitializeHotbarStepTwo();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void OnLocalPlayerConnect(PlayerControllerB __instance)
		{
			if (!ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				((MonoBehaviour)__instance).StartCoroutine(ArrangeHotbarLate());
			}
		}

		private static IEnumerator ArrangeHotbarLate()
		{
			ArrangeHotbar(Perks.InventorySlots());
			yield return (object)new WaitForEndOfFrame();
			ArrangeHotbar(Perks.InventorySlots());
		}

		private static void InitializeHotbarStepTwo()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_062e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0645: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Expected O, but got Unknown
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			HUDManager instance = HUDManager.Instance;
			Image[] itemSlotIcons = instance.itemSlotIcons;
			Image[] itemSlotIconFrames = instance.itemSlotIconFrames;
			float num = 0f;
			Inventory = ((Component)itemSlotIconFrames[0]).transform.parent;
			((Component)Inventory).gameObject.SetActive(true);
			InventoryGridLayout = ((Component)Inventory).gameObject.AddComponent<GridLayoutGroup>();
			InventoryGridLayout.constraint = (Constraint)2;
			InventoryGridLayout.constraintCount = 1;
			((LayoutGroup)InventoryGridLayout).childAlignment = (TextAnchor)7;
			InventoryGridLayout.cellSize = new Vector2(40f, 40f);
			InventoryGridLayout.spacing = new Vector2(5f, 0f);
			Inventory.localScale = Vector3.one;
			for (int i = 0; i < 13; i++)
			{
				if (i < 13 && i >= 10)
				{
					((Component)itemSlotIcons[i]).transform.localPosition = Vector2.op_Implicit(new Vector2(0f, -3.2f));
					Animator component = ((Component)itemSlotIconFrames[i]).GetComponent<Animator>();
					if (!(component.runtimeAnimatorController is AnimatorOverrideController))
					{
						AnimatorOverrideController val = new AnimatorOverrideController(component.runtimeAnimatorController);
						AnimationClipOverrides animationClipOverrides = new AnimationClipOverrides(50);
						component.runtimeAnimatorController = (RuntimeAnimatorController)(object)val;
						val.GetOverrides((List<KeyValuePair<AnimationClip, AnimationClip>>)animationClipOverrides);
						animationClipOverrides["PanelLines"] = EquipmentFrameAnimation;
						animationClipOverrides["PanelEnlarge"] = EquipmentFrameEnlargeAnimation;
						val.ApplyOverrides((IList<KeyValuePair<AnimationClip, AnimationClip>>)animationClipOverrides);
					}
					((Graphic)itemSlotIconFrames[i]).color = new Color(0.4f, 0.4f, 0.4f);
					if (i == 10)
					{
						GameObject val2 = new GameObject("helmet");
						val2.transform.parent = ((Component)itemSlotIconFrames[i]).transform;
						val2.transform.localScale = new Vector3(1f, 1f, 1f);
						val2.transform.localPosition = new Vector3(0f, 0f, 0f);
						HelmetImage = val2.AddComponent<Image>();
						((Graphic)HelmetImage).rectTransform.sizeDelta = new Vector2(16f, 16f);
						((Graphic)HelmetImage).rectTransform.anchorMax = new Vector2(0.5f, 1f);
						((Graphic)HelmetImage).rectTransform.anchorMin = new Vector2(0.5f, 1f);
						((Graphic)HelmetImage).rectTransform.pivot = new Vector2(0.5f, 1f);
						((Graphic)HelmetImage).rectTransform.anchoredPosition = new Vector2(0f, -4f);
						HelmetImage.sprite = HelmetIcon;
					}
					if (i == 11)
					{
						GameObject val3 = new GameObject("body");
						val3.transform.parent = ((Component)itemSlotIconFrames[i]).transform;
						val3.transform.localScale = new Vector3(1f, 1f, 1f);
						val3.transform.localPosition = new Vector3(0f, 0f, 0f);
						BodyImage = val3.AddComponent<Image>();
						((Graphic)BodyImage).rectTransform.sizeDelta = new Vector2(16f, 16f);
						((Graphic)BodyImage).rectTransform.anchorMax = new Vector2(0.5f, 1f);
						((Graphic)BodyImage).rectTransform.anchorMin = new Vector2(0.5f, 1f);
						((Graphic)BodyImage).rectTransform.pivot = new Vector2(0.5f, 1f);
						((Graphic)BodyImage).rectTransform.anchoredPosition = new Vector2(0f, -4f);
						BodyImage.sprite = BodyIcon;
					}
					if (i == 12)
					{
						GameObject val4 = new GameObject("shoes");
						val4.transform.parent = ((Component)itemSlotIconFrames[i]).transform;
						val4.transform.localScale = new Vector3(1f, 1f, 1f);
						val4.transform.localPosition = new Vector3(0f, 0f, 0f);
						ShoesImage = val4.AddComponent<Image>();
						((Graphic)ShoesImage).rectTransform.sizeDelta = new Vector2(16f, 16f);
						((Graphic)ShoesImage).rectTransform.anchorMax = new Vector2(0.5f, 1f);
						((Graphic)ShoesImage).rectTransform.anchorMin = new Vector2(0.5f, 1f);
						((Graphic)ShoesImage).rectTransform.pivot = new Vector2(0.5f, 1f);
						((Graphic)ShoesImage).rectTransform.anchoredPosition = new Vector2(0f, -4f);
						ShoesImage.sprite = ShoesIcon;
					}
				}
				else
				{
					((Graphic)itemSlotIconFrames[i]).rectTransform.anchoredPosition = new Vector2(((Graphic)itemSlotIconFrames[i]).rectTransform.anchoredPosition.x, 0f);
				}
			}
			for (int j = 0; j < 13; j++)
			{
				if ((Object)(object)EnergyBars[j] == (Object)null)
				{
					EnergyBars[j] = Object.Instantiate<GameObject>(EnergyPrefab, ((Component)itemSlotIconFrames[j]).transform);
					EnergyInnerBars[j] = ((Component)EnergyBars[j].transform.GetChild(0)).gameObject.GetComponent<RectTransform>();
					EnergyBars[j].SetActive(false);
				}
				RectTransform component2 = EnergyBars[j].GetComponent<RectTransform>();
				if (j < 10)
				{
					component2.pivot = new Vector2(0.5f, 1f);
					component2.anchorMin = new Vector2(0.5f, 0f);
					component2.anchorMax = new Vector2(0.5f, 0f);
					component2.anchoredPosition = new Vector2(0f, -5f);
				}
				else
				{
					component2.pivot = new Vector2(0.5f, 0f);
					component2.anchorMin = new Vector2(0f, 0.5f);
					component2.anchorMax = new Vector2(0f, 0.5f);
					component2.anchoredPosition = new Vector2(-5f, 0f);
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "PlayFirstDayShipAnimation")]
		[HarmonyPostfix]
		public static void PlayFirstDayShipAnimation(HUDManager __instance)
		{
			if (!ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				ArrangeHotbar(Perks.InventorySlots());
			}
		}

		[HarmonyPatch(typeof(HUDManager), "Update")]
		[HarmonyPostfix]
		public static void UpdateHotbar(HUDManager __instance)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar || !((Object)(object)GameNetworkManager.Instance != (Object)null) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			EquipmentSlots.localScale = new Vector3(0.5f + 0.5f * EquipmentPhase / 2f, 0.5f + 0.5f * EquipmentPhase / 2f, 0.5f + 0.5f * EquipmentPhase / 2f);
			float equipmentPhase = EquipmentPhase;
			if (InEquipmentSlots && EquipmentPhase < 1f)
			{
				EquipmentPhase = Mathf.Clamp01(EquipmentPhase + Time.deltaTime * 5f);
			}
			else if (!InEquipmentSlots && EquipmentPhase > 0f)
			{
				EquipmentPhase = Mathf.Clamp01(EquipmentPhase - Time.deltaTime * 5f);
			}
			if (EquipmentPhase != equipmentPhase)
			{
				ArrangeHotbar(Perks.InventorySlots());
			}
			for (int i = 0; i < 13; i++)
			{
				if ((Object)(object)EnergyBars[i] != (Object)null)
				{
					if ((Object)(object)localPlayerController.ItemSlots[i] != (Object)null && localPlayerController.ItemSlots[i].itemProperties.requiresBattery)
					{
						EnergyBars[i].SetActive(true);
						EnergyInnerBars[i].sizeDelta = new Vector2(89f * (localPlayerController.ItemSlots[i].insertedBattery?.charge ?? 0f), EnergyInnerBars[i].sizeDelta.y);
					}
					else
					{
						EnergyBars[i].SetActive(false);
					}
				}
			}
		}

		public static void ArrangeHotbar(int hotbarSize)
		{
			//IL_0060: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar || (Object)(object)Inventory == (Object)null)
			{
				return;
			}
			EquipmentGridLayout.cellSize = new Vector2(80f * ClientConfiguration.Instance.Hotbar.HotbarScale, 93.535355f * ClientConfiguration.Instance.Hotbar.HotbarScale);
			EquipmentGridLayout.spacing = new Vector2(0f, 10f * ClientConfiguration.Instance.Hotbar.HotbarScale);
			InventoryGridLayout.spacing = new Vector2(ClientConfiguration.Instance.Hotbar.HotbarSpacing, 0f);
			RectTransform component = ((Component)HUDManager.Instance.Inventory.canvasGroup).GetComponent<RectTransform>();
			RectTransform component2 = ((Component)((Transform)component).parent).GetComponent<RectTransform>();
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			component2.GetWorldCorners(array);
			Canvas componentInParent = ((Component)component2).GetComponentInParent<Canvas>();
			Vector3 val = componentInParent.worldCamera.WorldToScreenPoint(array[1]);
			Vector3 val2 = componentInParent.worldCamera.WorldToScreenPoint(array[2]);
			Vector2 val3 = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle(component2, Vector2.op_Implicit(val), componentInParent.worldCamera, ref val3);
			Vector2 val4 = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle(component2, Vector2.op_Implicit(val2), componentInParent.worldCamera, ref val4);
			float num = ClientConfiguration.Instance.Hotbar.HotbarScale * 1.75f;
			float num2 = 200f;
			float num3 = 40f * ClientConfiguration.Instance.Hotbar.HotbarScale;
			Rect rect = component2.rect;
			float num4 = ((Rect)(ref rect)).width;
			float num5 = ((float)hotbarSize * 40f + (float)(hotbarSize - 1) * ClientConfiguration.Instance.Hotbar.HotbarSpacing) * num;
			if (num4 / 2f - num5 / 2f < num2)
			{
				num4 -= num2;
				component.offsetMin = new Vector2(200f, ClientConfiguration.Instance.Hotbar.HotbarY / 100f * 40f);
				((LayoutGroup)InventoryGridLayout).childAlignment = (TextAnchor)6;
			}
			else
			{
				component.offsetMin = new Vector2(-35f, ClientConfiguration.Instance.Hotbar.HotbarY / 100f * 40f);
				((LayoutGroup)InventoryGridLayout).childAlignment = (TextAnchor)7;
			}
			if (num4 - num3 < num5)
			{
				num *= (num4 - num3) / num5;
			}
			InventoryGridLayout.cellSize = new Vector2(40f * num, 40f * num);
			Vector2 val5 = default(Vector2);
			RectTransformUtility.ScreenPointToLocalPointInRectangle(component, Vector2.op_Implicit(val2), componentInParent.worldCamera, ref val5);
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(0f, 0f);
			float x = val5.x;
			rect = component2.rect;
			component.offsetMax = new Vector2(x - (((Rect)(ref rect)).width - component.offsetMin.x), 100f + ClientConfiguration.Instance.Hotbar.HotbarY);
			int num6 = 0;
			int num7 = 0;
			for (int i = 0; i < 13; i++)
			{
				Image val6 = HUDManager.Instance.itemSlotIconFrames[i];
				((Component)val6).GetComponent<Image>().pixelsPerUnitMultiplier = 10f - ClientConfiguration.Instance.Hotbar.HotbarBorderWidth / 12f;
				Image val7 = HUDManager.Instance.itemSlotIcons[i];
				InventoryType inventoryType = i switch
				{
					12 => InventoryType.SHOES, 
					11 => InventoryType.BODY, 
					10 => InventoryType.HELMET, 
					_ => InventoryType.INVENTORY, 
				};
				RectTransform component3 = EnergyBars[i].GetComponent<RectTransform>();
				if (inventoryType == InventoryType.INVENTORY)
				{
					component3.anchoredPosition = new Vector2(0f, -3f * num);
					((Transform)component3).localScale = new Vector3(InventoryGridLayout.cellSize.x / 100f, InventoryGridLayout.cellSize.x / 100f, 1f);
					((Transform)((Graphic)val7).rectTransform).localScale = Vector3.one;
					((Graphic)val7).rectTransform.offsetMin = new Vector2(5f * num, 5f * num);
					((Graphic)val7).rectTransform.offsetMax = new Vector2(-5f * num, -5f * num);
					bool active = i < hotbarSize;
					((Component)val6).gameObject.SetActive(active);
				}
				else
				{
					component3.anchoredPosition = new Vector2(-20f * ClientConfiguration.Instance.Hotbar.HotbarScale, -7f * ClientConfiguration.Instance.Hotbar.HotbarScale);
					((Transform)component3).rotation = Quaternion.Euler(0f, 0f, 90f);
					((Transform)component3).localScale = new Vector3(EquipmentGridLayout.cellSize.x / 100f, 0f - EquipmentGridLayout.cellSize.x / 100f, 1f);
					((Transform)((Graphic)val7).rectTransform).localScale = Vector3.one;
					((Graphic)val7).rectTransform.offsetMin = new Vector2(5f * ClientConfiguration.Instance.Hotbar.HotbarScale, 5f * ClientConfiguration.Instance.Hotbar.HotbarScale);
					((Graphic)val7).rectTransform.offsetMax = new Vector2(-5f * ClientConfiguration.Instance.Hotbar.HotbarScale, -15f * ClientConfiguration.Instance.Hotbar.HotbarScale);
					bool active2 = (inventoryType == InventoryType.HELMET && HeadSlotAvailable) || (inventoryType == InventoryType.BODY && BodySlotAvailable) || (inventoryType == InventoryType.SHOES && FeetSlotAvailable);
					Transform child = ((Component)val6).transform.GetChild(1);
					RectTransform component4 = ((Component)child).GetComponent<RectTransform>();
					((Transform)component4).localScale = new Vector3(ClientConfiguration.Instance.Hotbar.HotbarScale, ClientConfiguration.Instance.Hotbar.HotbarScale, ClientConfiguration.Instance.Hotbar.HotbarScale);
					((Component)val6).gameObject.SetActive(active2);
				}
			}
		}

		public static void ArrangeFrame(int index, bool isActive, Vector2 position, InventoryType type)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				Image val = HUDManager.Instance.itemSlotIconFrames[index];
				((Graphic)val).rectTransform.anchoredPosition = position + (Vector2)((type == InventoryType.INVENTORY) ? Vector2.zero : new Vector2((0f - ((Graphic)val).rectTransform.sizeDelta.x) / 2f, ((Graphic)val).rectTransform.sizeDelta.y / 2f));
				((Component)val).gameObject.SetActive(isActive);
			}
		}

		[HarmonyPatch(typeof(HUDManager), "Update")]
		[HarmonyPrefix]
		private static void ObserveWindowSize()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (!ServerConfiguration.Instance.General.DeactivateHotbar && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null && (Object)(object)Inventory != (Object)null)
			{
				if (UpdateNextFrame)
				{
					ArrangeHotbar(Perks.InventorySlots());
					UpdateNextFrame = false;
				}
				float x = ((Component)Inventory.parent).GetComponent<RectTransform>().offsetMax.x;
				Rect rect = ((Component)Inventory.parent).GetComponent<RectTransform>().rect;
				float width = ((Rect)(ref rect)).width;
				if (x != PreviousAnchorMax && width != PreviousWidth)
				{
					UpdateNextFrame = true;
					PreviousAnchorMax = x;
					PreviousWidth = width;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPrefix]
		private static void SetHoverTipAndCurrentInteractTrigger(PlayerControllerB __instance)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return;
			}
			if (!__instance.isGrabbingObjectAnimation)
			{
				Ray val = default(Ray);
				((Ray)(ref val))..ctor(((Component)__instance.gameplayCamera).transform.position, ((Component)__instance.gameplayCamera).transform.forward);
				RaycastHit val2 = default(RaycastHit);
				if (Physics.Raycast(val, ref val2, __instance.grabDistance, 832) && ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer != 8)
				{
					GameObject gameObject = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
					HoveringObject = gameObject.GetComponent<GrabbableObject>();
					return;
				}
			}
			HoveringObject = null;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchGrabObjectClientRpc(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase methodBase)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->GrabObjectClientRpc...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && list[i].opcode == OpCodes.Call && list[i].operand.ToString().Contains("SwitchToItemSlot"))
				{
					List<CodeInstruction> list2 = new List<CodeInstruction>();
					list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					list2.Add(list[i - 3]);
					list2.Add(list[i - 2]);
					list2.Add(list[i - 1]);
					list2.Add(new CodeInstruction(OpCodes.Stfld, (object)typeof(PlayerControllerB).GetField("currentlyGrabbingObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)));
					List<CodeInstruction> list3 = list2;
					CodeInstructionExtensions.MoveLabelsFrom(list3[0], list[i - 6]);
					for (int num = list3.Count - 1; num >= 0; num--)
					{
						list.Insert(i - 6, list3[num]);
					}
					flag = true;
				}
				if (flag)
				{
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->GrabObjectClientRpc...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "FirstEmptyItemSlot")]
		[HarmonyPrefix]
		public static bool FirstEmptyItemSlot(PlayerControllerB __instance, ref int __result)
		{
			if (ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				return true;
			}
			__result = -1;
			GrabbableObject currentlyGrabbingObject = __instance.currentlyGrabbingObject;
			int num = Perks.InventorySlotsOf(__instance);
			GrabbableObject val = null;
			if ((Object)(object)currentlyGrabbingObject != (Object)null)
			{
				val = currentlyGrabbingObject;
			}
			if ((Object)(object)val == (Object)null)
			{
				val = HoveringObject;
			}
			InventoryType inventoryType = ((__instance.currentItemSlot == 10) ? InventoryType.HELMET : ((__instance.currentItemSlot == 11) ? InventoryType.BODY : ((__instance.currentItemSlot == 12) ? InventoryType.SHOES : InventoryType.INVENTORY)));
			if ((Object)(object)val != (Object)null)
			{
				InventoryType inventoryType2 = ((val is Helmet) ? InventoryType.HELMET : ((val is Body) ? InventoryType.BODY : ((val is Boots) ? InventoryType.SHOES : InventoryType.INVENTORY)));
				if ((Object)(object)__instance.ItemSlots[__instance.currentItemSlot] == (Object)null && (inventoryType == InventoryType.INVENTORY || inventoryType2 == inventoryType))
				{
					__result = __instance.currentItemSlot;
				}
				else
				{
					for (int i = 0; i < num; i++)
					{
						if ((Object)(object)__instance.ItemSlots[i] == (Object)null)
						{
							__result = i;
							break;
						}
					}
					if (__result == -1 && inventoryType2 != 0)
					{
						Clothing clothing = (Clothing)(object)val;
						int equipmentSlot = clothing.GetEquipmentSlot();
						if ((Object)(object)__instance.ItemSlots[equipmentSlot] == (Object)null)
						{
							__result = equipmentSlot;
						}
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSwitchToItemSlot(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase methodBase)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->SwitchToItemSlot...");
			MethodInfo method = typeof(GrabbableObjectAdditions).GetMethod("GetIcon", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			MethodInfo method2 = typeof(ClientConfiguration).GetMethod("GetHotbarAlpha", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "UnityEngine.Sprite itemIcon")
				{
					list.RemoveAt(i);
					list.Insert(i, new CodeInstruction(OpCodes.Call, (object)method));
					list.RemoveAt(i - 1);
					flag = true;
				}
				if (list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 0.13f)
				{
					list[i].opcode = OpCodes.Call;
					list[i].operand = method2;
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->SwitchToItemSlot...");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	internal class ItemDataHandling
	{
		public static Dictionary<int, SelectableLevel> Moons = new Dictionary<int, SelectableLevel>();

		private static Dictionary<PlayerControllerB, AnimatorOverrideController> Animators = new Dictionary<PlayerControllerB, AnimatorOverrideController>();

		private static Dictionary<PlayerControllerB, AnimationClipOverrides> Overrides = new Dictionary<PlayerControllerB, AnimationClipOverrides>();

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPrefix]
		public static void AddItemsToLootTable(StartOfRound __instance)
		{
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0414: Expected O, but got Unknown
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			foreach (KeyValuePair<int, Item> itemProperty in AdvancedCompany.Game.Manager.ItemProperties)
			{
				if (__instance.allItemsList.itemsList.Contains(itemProperty.Value))
				{
					continue;
				}
				__instance.allItemsList.itemsList.Add(itemProperty.Value);
				WalkieTalkie component = itemProperty.Value.spawnPrefab.GetComponent<WalkieTalkie>();
				if (!((Object)(object)component != (Object)null))
				{
					continue;
				}
				component.target = ((Component)((Component)component).transform.Find("Target")).GetComponent<AudioSource>();
				component.thisAudio = ((Component)component).GetComponent<AudioSource>();
				foreach (Item items in __instance.allItemsList.itemsList)
				{
					if (items.itemName == "Walkie-talkie")
					{
						WalkieTalkie component2 = items.spawnPrefab.GetComponent<WalkieTalkie>();
						component.talkingOnWalkieTalkieNotHeldSFX = component2.talkingOnWalkieTalkieNotHeldSFX;
						component.switchWalkieTalkiePowerOn = component2.switchWalkieTalkiePowerOn;
						component.switchWalkieTalkiePowerOff = component2.switchWalkieTalkiePowerOff;
						component.stopTransmissionSFX = component2.stopTransmissionSFX;
						component.startTransmissionSFX = component2.startTransmissionSFX;
						component.recordingRange = component2.recordingRange;
						component.playerDieOnWalkieTalkieSFX = component2.playerDieOnWalkieTalkieSFX;
						break;
					}
				}
			}
			SelectableLevel[] levels = __instance.levels;
			foreach (SelectableLevel val in levels)
			{
				if (((Object)val).name == "ExperimentationLevel")
				{
					Moons[1] = val;
				}
				if (((Object)val).name == "AssuranceLevel")
				{
					Moons[3] = val;
				}
				if (((Object)val).name == "VowLevel")
				{
					Moons[2] = val;
				}
				if (((Object)val).name == "MarchLevel")
				{
					Moons[5] = val;
				}
				if (((Object)val).name == "RendLevel")
				{
					Moons[6] = val;
				}
				if (((Object)val).name == "DineLevel")
				{
					Moons[7] = val;
				}
				if (((Object)val).name == "OffenseLevel")
				{
					Moons[4] = val;
				}
				if (((Object)val).name == "TitanLevel")
				{
					Moons[8] = val;
				}
			}
			foreach (KeyValuePair<int, ItemData> addedItem in AdvancedCompany.Game.Manager.AddedItems)
			{
				if (!addedItem.Value.IsScrap)
				{
					continue;
				}
				if (addedItem.Value.LimitPlanets)
				{
					for (int j = 0; j < 9; j++)
					{
						if (Moons.ContainsKey(j) && addedItem.Value.PlanetRarities[j] > 0)
						{
							Moons[j].spawnableScrap.Add(new SpawnableItemWithRarity
							{
								rarity = addedItem.Value.PlanetRarities[j],
								spawnableItem = AdvancedCompany.Game.Manager.ItemProperties[addedItem.Value.ID]
							});
						}
					}
					continue;
				}
				foreach (KeyValuePair<int, SelectableLevel> moon in Moons)
				{
					moon.Value.spawnableScrap.Add(new SpawnableItemWithRarity
					{
						rarity = addedItem.Value.Rarity,
						spawnableItem = AdvancedCompany.Game.Manager.ItemProperties[addedItem.Value.ID]
					});
				}
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "LateUpdate")]
		[HarmonyPrefix]
		public static bool GrabbableObjectLateUpdate(GrabbableObject __instance)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			ItemData component = ((Component)__instance).GetComponent<ItemData>();
			if ((Object)(object)component != (Object)null && (Object)(object)__instance.parentObject != (Object)null)
			{
				if (((Object)__instance.parentObject).name == "LocalItemHolder")
				{
					((Component)__instance).transform.rotation = __instance.parentObject.rotation;
					((Component)__instance).transform.Rotate(component.EgoHeldRotation);
					((Component)__instance).transform.position = __instance.parentObject.position;
					Transform transform = ((Component)__instance).transform;
					transform.position += __instance.parentObject.rotation * component.EgoHeldPosition;
					return false;
				}
				if (((Object)__instance.parentObject).name == "ServerItemHolder")
				{
					((Component)__instance).transform.rotation = __instance.parentObject.rotation;
					((Component)__instance).transform.Rotate(component.HeldRotation);
					((Component)__instance).transform.position = __instance.parentObject.position;
					Transform transform2 = ((Component)__instance).transform;
					transform2.position += __instance.parentObject.rotation * component.HeldPosition;
					return false;
				}
			}
			return true;
		}

		private static IEnumerable<CodeInstruction> PatchUpdate(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->Update...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			bool flag2 = true;
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 2.25f)
				{
					list.RemoveAt(i + 2);
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("SprintSpeed", list, i + 2);
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("SprintSpeed", list, i + 1, addMul: false);
					flag = true;
				}
				if (!flag2 && list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single climbSpeed")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ClimbSpeed", list, i + 1);
					flag2 = true;
				}
				if (flag && flag2)
				{
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->Update...");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	internal class ItemDropship
	{
		[HarmonyPatch(typeof(ItemDropship), "Update")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase method)
		{
			Plugin.Log.LogDebug((object)"Patching ItemDropship->Update...");
			PropertyInfo property = typeof(Perks).GetProperty("DropshipTime", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].operand is float num && num == 40f)
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("DeliverySpeed", list, i + 1);
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched ItemDropship->Update...");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	[Bootable]
	internal class LobbySizePatches
	{
		public const int MAX_SUPPORTED_PLAYERS = 32;

		internal static Sync Handshake;

		internal static Dictionary<ulong, Sync> ConnectingClients = new Dictionary<ulong, Sync>();

		private static GameObject JoiningLateScreenPrefab;

		private static GameObject JoiningLateScreen;

		private static TextMeshProUGUI DebugText;

		private static MethodInfo GetLobbySizeMethod = typeof(LobbySizePatches).GetMethod("GetLobbySize", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		private static MethodInfo GameObjectSetActive = typeof(GameObject).GetMethod("SetActive", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		private static PropertyInfo StartOfRoundInstance = typeof(StartOfRound).GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo StartOfRoundAllPlayerScripts = typeof(StartOfRound).GetField("allPlayerScripts", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo NetworkObjectGlobalObjectIdHash = typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo NetworkSceneManagerScenePlacedObjects = typeof(NetworkSceneManager).GetField("ScenePlacedObjects", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static AudioMixer NewAudioMixer32;

		private static AudioMixer NewAudioMixer28;

		private static AudioMixer NewAudioMixer24;

		private static AudioMixer NewAudioMixer20;

		private static AudioMixer NewAudioMixer16;

		private static AudioMixer NewAudioMixer12;

		private static AudioMixer NewAudioMixer8;

		private static AudioMixer NewAudioMixer4;

		private static AudioMixer OriginalMixer;

		private static GameObject ScrollViewPrefab;

		private static PropertyInfo LobbyMaxMembers = typeof(Lobby).GetProperty("MaxMembers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		public static AudioMixer PlayerMixer;

		protected static FieldInfo PlayerMixerField = typeof(LobbySizePatches).GetField("PlayerMixer", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);

		private static ulong CurrentHandshakePlayer = 0uL;

		public static bool LobbyOpen = true;

		private static List<Sync> PendingRequests = new List<Sync>();

		private static int LastConnectingClientsCount = 0;

		private static FieldInfo CrawlerAINearPlayerColliders = typeof(CrawlerAI).GetField("nearPlayerColliders", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		private static FieldInfo ShipTeleporterPlayersBeingTeleported = typeof(ShipTeleporter).GetField("playersBeingTeleported", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		public static int NextPlayerSlot = 1;

		protected static List<ulong> ConnectedIDs = new List<ulong>();

		public static int GetLobbySize()
		{
			return ServerConfiguration.Instance.Lobby.LobbySize;
		}

		[HarmonyPatch(typeof(HUDManager), "ApplyPenalty")]
		[HarmonyPostfix]
		private static void ApplyPenalty(HUDManager __instance, ref int playersDead, ref int bodiesInsured)
		{
			playersDead -= AdvancedCompany.Network.Manager.Lobby.LateJoiners.Count;
			AdvancedCompany.Network.Manager.Lobby.LateJoiners.Clear();
		}

		[HarmonyPatch(typeof(HUDManager), "SetPlayerLevelSmoothly")]
		[HarmonyPostfix]
		private static void SetPlayerLevelSmoothly(HUDManager __instance, ref int XPGain)
		{
			if (AdvancedCompany.Network.Manager.Lobby.LateJoiners.Contains((int)StartOfRound.Instance.localPlayerController.playerClientId))
			{
				XPGain = 0;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		private static void DebugUpdate()
		{
			if ((Object)(object)DebugText != (Object)null)
			{
				string text = "";
				for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
					text = text + "Player " + i + ":\r\n";
					text = text + "isPlayerControlled: " + val.isPlayerControlled + "\r\n";
					text = text + "isDead: " + val.isPlayerDead + "\r\n";
					text = text + "clientId: " + val.actualClientId + "\r\n";
				}
				((TMP_Text)DebugText).text = text;
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SyncAlreadyHeldObjectsClientRpc")]
		[HarmonyPostfix]
		private static void StartOfRoundSyncAlreadyHeldObjectsClientRpc(StartOfRound __instance)
		{
			for (int i = 0; i < __instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = __instance.allPlayerScripts[i];
				for (int j = 0; j < val.ItemSlots.Length; j++)
				{
					GrabbableObject obj = val.ItemSlots[j];
					FlashlightItem val2 = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
					if (val2 != null)
					{
						InventoryPatches.UpdateFlashlightState(val2, !((GrabbableObject)val2).isPocketed);
					}
				}
			}
		}

		[HarmonyPatch(typeof(QuickMenuManager), "OpenQuickMenu")]
		[HarmonyPostfix]
		private static void OpenMenu_performed(QuickMenuManager __instance)
		{
			__instance.inviteFriendsTextAlpha.alpha = ((ServerConfiguration.Instance.Lobby.KeepOpenOnMoon || (ServerConfiguration.Instance.Lobby.KeepOpen && StartOfRound.Instance.inShipPhase) || !GameNetworkManager.Instance.gameHasStarted) ? 1f : 0.2f);
		}

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPostfix]
		private static void AddDebug(HUDManager __instance)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0085: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			Canvas componentInParent = ((Component)__instance.gameOverAnimator).gameObject.GetComponentInParent<Canvas>();
			if (Handshake != null)
			{
				LobbyDataSynchronization syncHandler = Handshake.GetSyncHandler<LobbyDataSynchronization>();
				if (syncHandler.OnMoon)
				{
					JoiningLateScreen = Object.Instantiate<GameObject>(JoiningLateScreenPrefab, ((Component)componentInParent).transform);
				}
			}
			if ((Object)(object)DebugText == (Object)null)
			{
				GameObject val = new GameObject("Debug text");
				val.transform.parent = ((Component)componentInParent).transform;
				val.transform.localScale = Vector3.one;
				RectTransform val2 = val.AddComponent<RectTransform>();
				val2.anchorMin = new Vector2(0f, 0f);
				val2.anchorMax = new Vector2(1f, 1f);
				val2.anchoredPosition3D = Vector3.zero;
				val2.pivot = new Vector2(0f, 0f);
				val2.offsetMax = new Vector2(0f, 0f);
				val2.offsetMin = new Vector2(0f, 0f);
				CanvasGroup val3 = val.AddComponent<CanvasGroup>();
				val3.interactable = false;
				DebugText = val.AddComponent<TextMeshProUGUI>();
				((TMP_Text)DebugText).fontSize = 12f;
				val.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void ConnectClientToPlayerObject(PlayerControllerB __instance)
		{
			if (Handshake != null)
			{
				Handshake.ConnectClientToPlayerObject(__instance);
			}
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(StartOfRound.Instance.allPlayerScripts[i]);
				player?.SetCosmetics(player.Cosmetics, sendMessage: false);
			}
		}

		[HarmonyPatch(typeof(RoundManager), "GenerateNewLevelClientRpc")]
		[HarmonyPostfix]
		private static void FinishedGeneratingLevelServerRpc(RoundManager __instance, int randomSeed, int levelID)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (Handshake != null && !__instance.currentLevel.spawnEnemiesAndScrap)
			{
				((NetworkBehaviour)RoundManager.Instance).__rpc_exec_stage = (__RpcExecStage)2;
				RoundManager.Instance.FinishGeneratingNewLevelClientRpc();
				((NetworkBehaviour)RoundManager.Instance).__rpc_exec_stage = (__RpcExecStage)0;
				LateJoinSpectate();
				Handshake.LevelLoaded();
				Handshake = null;
			}
		}

		[HarmonyPatch(typeof(RoundManager), "FinishedGeneratingLevelServerRpc")]
		[HarmonyPrefix]
		private static bool FinishedGeneratingLevelServerRpc(RoundManager __instance)
		{
			//IL_002a: 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)
			if (Handshake != null)
			{
				LobbyDataSynchronization syncHandler = Handshake.GetSyncHandler<LobbyDataSynchronization>();
				if (syncHandler.OnMoon)
				{
					((NetworkBehaviour)RoundManager.Instance).__rpc_exec_stage = (__RpcExecStage)2;
					RoundManager.Instance.FinishGeneratingNewLevelClientRpc();
					((NetworkBehaviour)RoundManager.Instance).__rpc_exec_stage = (__RpcExecStage)0;
					LateJoinSpectate();
					Handshake.LevelLoaded();
					Handshake = null;
					return false;
				}
				Handshake = null;
			}
			return true;
		}

		internal static void LateJoinSpectate()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			localPlayerController.isPlayerDead = true;
			localPlayerController.isPlayerControlled = false;
			((Renderer)localPlayerController.thisPlayerModelArms).enabled = false;
			localPlayerController.localVisor.position = localPlayerController.playersManager.notSpawnedPosition.position;
			localPlayerController.isInsideFactory = false;
			localPlayerController.IsInspectingItem = false;
			localPlayerController.inTerminalMenu = false;
			localPlayerController.twoHanded = false;
			localPlayerController.carryWeight = 1f;
			localPlayerController.fallValue = 0f;
			localPlayerController.fallValueUncapped = 0f;
			localPlayerController.takingFallDamage = false;
			localPlayerController.isSinking = false;
			localPlayerController.isUnderwater = false;
			StartOfRound.Instance.drowningTimer = 1f;
			HUDManager.Instance.setUnderwaterFilter = false;
			localPlayerController.wasUnderwaterLastFrame = false;
			localPlayerController.sourcesCausingSinking = 0;
			localPlayerController.sinkingValue = 0f;
			localPlayerController.hinderedMultiplier = 1f;
			localPlayerController.isMovementHindered = 0;
			localPlayerController.inAnimationWithEnemy = null;
			Object.FindObjectOfType<Terminal>().terminalInUse = false;
			localPlayerController.ChangeAudioListenerToObject(((Component)localPlayerController.playersManager.spectateCamera).gameObject);
			SoundManager.Instance.SetDiageticMixerSnapshot(0, 1f);
			HUDManager.Instance.gameOverAnimator.speed = 1000f;
			HUDManager.Instance.gameOverAnimator.SetTrigger("gameOver");
			HUDManager.Instance.HideHUD(true);
			StartOfRound.Instance.shipAnimator.speed = 1000f;
			localPlayerController.StopHoldInteractionOnTrigger();
			localPlayerController.KillPlayerServerRpc((int)localPlayerController.playerClientId, false, Vector3.zero, -1, -1);
			StartOfRound.Instance.SwitchCamera(StartOfRound.Instance.spectateCamera);
			localPlayerController.isInGameOverAnimation = 0.01f;
			((TMP_Text)localPlayerController.cursorTip).text = "";
			((Behaviour)localPlayerController.cursorIcon).enabled = false;
			localPlayerController.DropAllHeldItems(true, false);
			localPlayerController.DisableJetpackControlsLocally();
			((MonoBehaviour)HUDManager.Instance).StartCoroutine(HideLateJoinScreen());
			HUDManager.Instance.UpdateBoxesSpectateUI();
		}

		public static IEnumerator HideLateJoinScreen()
		{
			yield return (object)new WaitForSeconds(2f);
			HUDManager.Instance.gameOverAnimator.speed = 1f;
			StartOfRound.Instance.shipAnimator.speed = 1f;
			Object.Destroy((Object)(object)JoiningLateScreen);
		}

		public static void LoadAssets(AssetBundle assets)
		{
			NewAudioMixer32 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic32Players.mixer");
			NewAudioMixer28 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic28Players.mixer");
			NewAudioMixer24 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic24Players.mixer");
			NewAudioMixer20 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic20Players.mixer");
			NewAudioMixer16 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic16Players.mixer");
			NewAudioMixer12 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic12Players.mixer");
			NewAudioMixer8 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic8Players.mixer");
			NewAudioMixer4 = assets.LoadAsset<AudioMixer>("Assets/AudioMixer/Diagetic4Players.mixer");
			ScrollViewPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/ScrollView.prefab");
			JoiningLateScreenPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/LateJoin.prefab");
		}

		public static void PatchAsync()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			MethodInfo method = typeof(GameNetworkManager).GetMethod("StartHost", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			AsyncStateMachineAttribute customAttribute = method.GetCustomAttribute<AsyncStateMachineAttribute>();
			MethodInfo method2 = customAttribute.StateMachineType.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			Harmony val = new Harmony("AdvancedCompany");
			HarmonyMethod val2 = new HarmonyMethod(typeof(LobbySizePatches).GetMethod("TranspileStartHost"));
			val.Patch((MethodBase)method2, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo method3 = typeof(SteamLobbyManager).GetMethod("LoadServerList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			customAttribute = method3.GetCustomAttribute<AsyncStateMachineAttribute>();
			method2 = customAttribute.StateMachineType.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			val2 = new HarmonyMethod(typeof(LobbySizePatches).GetMethod("TranspileLoadServerList"));
			val.Patch((MethodBase)method2, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static IEnumerable<CodeInstruction> TranspileStartHost(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching GameNetworkManager->StartHost...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i - 1].opcode == OpCodes.Ldc_I4_4)
				{
					Plugin.Log.LogDebug((object)"Replacing SteamMatchmaking.CreateLobbyAsync(4) with SteamMatchmaking.CreateLobbyAsync(LobbySizePatches.GetLobbySize())");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = GetLobbySizeMethod;
				}
			}
			Plugin.Log.LogDebug((object)"Patched GameNetworkManager->StartHost!");
			return list.AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> TranspileLoadServerList(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching SteamLobbyManager->LoadServerList...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i].operand.ToString() == "Steamworks.Data.LobbyQuery WithKeyValue(System.String, System.String)")
				{
					Plugin.Log.LogDebug((object)"Adding .WithKeyValue(\"advcmpny\", Lib.Mod.GetHash()) to lobby search.");
					list.Insert(i + 1, list[i]);
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)typeof(Mod).GetMethod("GetHash", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)));
					list.Insert(i + 1, new CodeInstruction(OpCodes.Ldstr, (object)"advcmpny"));
					list.Insert(i + 1, list[i - 5]);
					list.Insert(i + 1, list[i - 6]);
					i += 5;
					num++;
					if (num == 3)
					{
						break;
					}
				}
			}
			Plugin.Log.LogDebug((object)"Patched SteamLobbyManager->LoadServerList...");
			return list.AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> ReplaceLowerThanFourWithPlayerCount(IEnumerable<CodeInstruction> instructions, bool lookForArray = false)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (((list[i].opcode == OpCodes.Blt || list[i].opcode == OpCodes.Blt_S) && list[i - 1].opcode == OpCodes.Ldc_I4_4) || (lookForArray && list[i].opcode == OpCodes.Newarr && list[i - 1].opcode == OpCodes.Ldc_I4_4))
				{
					Plugin.Log.LogDebug((object)"Replacing < 4 with < StartOfRound.Instance.allPlayerScripts.length");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = StartOfRoundInstance.GetMethod;
					list.Insert(i, new CodeInstruction(OpCodes.Conv_I4, (object)null));
					list.Insert(i, new CodeInstruction(OpCodes.Ldlen, (object)null));
					list.Insert(i, new CodeInstruction(OpCodes.Ldfld, (object)StartOfRoundAllPlayerScripts));
				}
			}
			return list.AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> ReplaceGreaterThanOrEqualFourWithMaxPlayers(IEnumerable<CodeInstruction> instructions, bool lookForArray = false)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if ((list[i].opcode == OpCodes.Blt || list[i].opcode == OpCodes.Blt_S || list[i].opcode == OpCodes.Bge || list[i].opcode == OpCodes.Bge_S) && list[i - 1].opcode == OpCodes.Ldc_I4_4)
				{
					Plugin.Log.LogDebug((object)"Replacing < 4 with < LobbyPatches.GetLobbySize()");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = GetLobbySizeMethod;
				}
			}
			return list.AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> SkipGameStarted(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if ((list[i].opcode == OpCodes.Brfalse || list[i].opcode == OpCodes.Brfalse_S) && list[i - 1].opcode == OpCodes.Ldfld && list[i - 1].operand.ToString().Contains("gameHasStarted"))
				{
					Plugin.Log.LogDebug((object)"Skipping GameNetworkManager->gameHasStarted");
					list[i - 2].opcode = OpCodes.Ldc_I4_0;
					list[i - 2].operand = null;
					list.RemoveAt(i - 1);
				}
				if ((list[i].opcode == OpCodes.Brtrue || list[i].opcode == OpCodes.Brtrue_S) && list[i - 1].opcode == OpCodes.Ldfld && list[i - 1].operand.ToString().Contains("gameHasStarted"))
				{
					Plugin.Log.LogDebug((object)"Skipping GameNetworkManager->gameHasStarted");
					list[i - 2].opcode = OpCodes.Ldc_I4_1;
					list[i - 2].operand = null;
					list.RemoveAt(i - 1);
				}
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundOnPlayerConnectedClientRpc(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->OnPlayerConnectedClientRpc...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Callvirt && list[i].operand.ToString().Contains("get_IsOwnedByServer") && list[i + 1].opcode == OpCodes.Brtrue)
				{
					object operand = list[i + 1].operand;
					List<CodeInstruction> list2 = new List<CodeInstruction>();
					list2.Add(list[i - 4]);
					list2.Add(list[i - 3]);
					list2.Add(list[i - 2]);
					list2.Add(list[i - 1]);
					list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)typeof(PlayerControllerB).GetField("isPlayerDead")));
					list2.Add(list[i + 1]);
					list.Insert(i - 5, new CodeInstruction(list[i - 6].opcode, list[i - 6].operand));
					list[i - 6].opcode = list2[0].opcode;
					list[i - 6].operand = list2[0].operand;
					for (int num = list2.Count - 1; num >= 1; num--)
					{
						list.Insert(i - 5, list2[num]);
					}
					Plugin.Log.LogDebug((object)"Adding && !StartOfRound::allPlayerScripts[j].isPlayerDead");
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched StartOfRound->OnPlayerConnectedClientRpc!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "LobbyDataIsJoinable")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchGameNetworkManagerLobbyDataIsJoinable(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching GameNetworkManager->LobbyDataIsJoinable...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if ((list[i].opcode == OpCodes.Bge || list[i].opcode == OpCodes.Bge_S) && list[i - 1].opcode == OpCodes.Ldc_I4_4)
				{
					Plugin.Log.LogDebug((object)"Replacing >= 4 with >=4 lobby.MaxMembers");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = LobbyMaxMembers.GetMethod;
					list.Insert(i - 1, list[i - 3]);
				}
			}
			Plugin.Log.LogDebug((object)"Patched GameNetworkManager->LobbyDataIsJoinable!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchGameNetworkManagerConnectionApproval(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching GameNetworkManager->ConnectionApproval...");
			instructions = SkipGameStarted(instructions);
			instructions = ReplaceGreaterThanOrEqualFourWithMaxPlayers(instructions);
			Plugin.Log.LogDebug((object)"Patched GameNetworkManager->ConnectionApproval!");
			return instructions;
		}

		[HarmonyPatch(typeof(StartOfRound), "StartGame")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundStartGame(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching StartOfRound->StartGame...");
			Plugin.Log.LogDebug((object)"Patched StartOfRound->StartGame!");
			return instructions;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundopeningDoorsSequence(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching StartOfRound->openingDoorsSequence...");
			Plugin.Log.LogDebug((object)"Patched StartOfRound->openingDoorsSequence!");
			return instructions;
		}

		[HarmonyPatch(typeof(DressGirlAI), "ChoosePlayerToHaunt")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchDressGirlAIChoosePlayerToHaunt(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching DressGirlAI->ChoosePlayerToHunt...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions, lookForArray: true);
			Plugin.Log.LogDebug((object)"Patched DressGirlAI->ChoosePlayerToHunt!");
			return instructions;
		}

		[HarmonyPatch(typeof(EnemyAI), "GetClosestPlayer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchEnemyAIGetClosestPlayer(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching EnemyAI->GetClosestPlayer...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			Plugin.Log.LogDebug((object)"Patched EnemyAI->GetClosestPlayer!");
			return instructions;
		}

		[HarmonyPatch(typeof(SpringManAI), "DoAIInterval")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSpringManAIDoAIInterval(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching SpringManAI->DoAIInterval...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			Plugin.Log.LogDebug((object)"Patched SpringManAI->DoAIInterval!");
			return instructions;
		}

		[HarmonyPatch(typeof(SpringManAI), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSpringManAIUpdate(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching SpringManAI->Update...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			Plugin.Log.LogDebug((object)"Patched SpringManAI->Update!");
			return instructions;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesServerRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSendNewPlayerValuesServerRpc(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->SendNewPlayerValuesServerRpc...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->SendNewPlayerValuesServerRpc!");
			return instructions;
		}

		[HarmonyPatch(typeof(QuickMenuManager), "ConfirmKickUserFromServer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchQuickMenuManagerConfirmKickUserFromServer(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching QuickMenuManager->ConfirmKickUserFromServer...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if ((list[i].opcode == OpCodes.Bgt || list[i].opcode == OpCodes.Bgt_S) && list[i - 1].opcode == OpCodes.Ldc_I4_3)
				{
					Plugin.Log.LogDebug((object)"Replacing > 4 with > LobbyPatches.GetLobbySize()");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = GetLobbySizeMethod;
				}
			}
			Plugin.Log.LogDebug((object)"Patched QuickMenuManager->ConfirmKickUserFromServer!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SpectateNextPlayer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSpectateNextPlayer(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->SpectateNextPlayer...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Rem && list[i - 1].opcode == OpCodes.Ldc_I4_4)
				{
					Plugin.Log.LogDebug((object)"Replacing % 4 with % LobbyPatches.GetLobbySize()");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = GetLobbySizeMethod;
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->SpectateNextPlayer!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(HUDManager), "SyncAllPlayerLevelsServerRpc", new Type[] { })]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchHUDManagerSyncAllPlayerLevelsServerRpc(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching HUDManager->SyncAllPlayerLevelsServerRpc...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions, lookForArray: true);
			Plugin.Log.LogDebug((object)"Patched HUDManager->SyncAllPlayerLevelsServerRpc!");
			return instructions;
		}

		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundOnClientConnect(IEnumerable<CodeInstruction> instructions)
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->OnClientConnect...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions, lookForArray: true);
			MethodInfo method = typeof(Lobby).GetMethod("GetPlayerNum", BindingFlags.Static | BindingFlags.Public);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Stfld && list[i].operand.ToString().Contains("actualClientId"))
				{
					Plugin.Log.LogDebug((object)"Adding num = Network.Lobby.GetPlayerNum(clientId)");
					List<CodeInstruction> list2 = new List<CodeInstruction>
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null),
						new CodeInstruction(OpCodes.Call, (object)method),
						new CodeInstruction(OpCodes.Stloc_1, (object)null)
					};
					list.Insert(i - 4, new CodeInstruction(list[i - 5].opcode, list[i - 5].operand));
					list[i - 5].opcode = list2[0].opcode;
					list[i - 5].operand = list2[0].operand;
					for (int num = list2.Count - 1; num >= 1; num--)
					{
						list.Insert(i - 4, list2[num]);
					}
					i += 2;
					break;
				}
			}
			instructions = list.AsEnumerable();
			Plugin.Log.LogDebug((object)"Patched StartOfRound->OnClientConnect!");
			return instructions;
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientDisconnectCallback")]
		[HarmonyPostfix]
		private static void PostfixOnClientConnect(GameNetworkManager __instance, ulong clientId)
		{
			if (ConnectingClients.ContainsKey(clientId))
			{
				Plugin.Log.LogInfo((object)("Connection disconnected. Removing " + clientId + " from connecting clients list."));
				ConnectingClients[clientId].IsFinished = true;
				PendingRequests.Remove(ConnectingClients[clientId]);
				ConnectingClients.Remove(clientId);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		[HarmonyPostfix]
		private static void PostfixOnClientConnect(StartOfRound __instance, ulong clientId)
		{
			if (ConnectingClients.ContainsKey(clientId))
			{
				Plugin.Log.LogInfo((object)("Connection complete. Removing " + clientId + " from connecting clients list."));
				ConnectingClients[clientId].IsFinished = true;
				PendingRequests.Remove(ConnectingClients[clientId]);
				ConnectingClients.Remove(clientId);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesServerRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundSyncShipUnlockablesServerRpc(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching StartOfRound->SyncShipUnlockablesServerRpc...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions, lookForArray: true);
			Plugin.Log.LogDebug((object)"Patched StartOfRound->SyncShipUnlockablesServerRpc!");
			return instructions;
		}

		[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchStartOfRoundSyncShipUnlockablesClientRpc(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching StartOfRound->SyncShipUnlockablesClientRpc...");
			instructions = ReplaceLowerThanFourWithPlayerCount(instructions);
			Plugin.Log.LogDebug((object)"Patched StartOfRound->SyncShipUnlockablesClientRpc!");
			return instructions;
		}

		[HarmonyPatch(typeof(QuickMenuManager), "AddUserToPlayerList")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchQuickMenuManagerAddUserToPlayerList(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching QuickMenuManager->AddUserToPlayerList...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ble && list[i - 1].opcode == OpCodes.Ldc_I4_4)
				{
					Plugin.Log.LogDebug((object)"Replacing <= 4 with <= LobbyPatches->GetLobbySize() - 1");
					list[i - 1].opcode = OpCodes.Call;
					list[i - 1].operand = GetLobbySizeMethod;
					list.Insert(i, new CodeInstruction(OpCodes.Sub, (object)null));
					list.Insert(i, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
				}
			}
			Plugin.Log.LogDebug((object)"Patched QuickMenuManager->AddUserToPlayerList!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(SoundManager), "SetPlayerPitch")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSetPlayerPitch(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching SoundManager->PatchSetPlayerPitch...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "UnityEngine.Audio.AudioMixer diageticMixer")
				{
					Plugin.Log.LogDebug((object)"Replacing SoundManger->diageticMixer with LobbyPatches->PlayerMixer");
					list[i].opcode = OpCodes.Ldsfld;
					list[i].operand = PlayerMixerField;
					list.RemoveAt(i - 1);
					i++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched SoundManager->PatchSetPlayerPitch!");
			return list.AsEnumerable();
		}

		public static string ChatReplace(string message)
		{
			StartOfRound instance = StartOfRound.Instance;
			for (int i = 4; i < instance.allPlayerScripts.Length; i++)
			{
				message = message.Replace("[playerNum" + i + "]", instance.allPlayerScripts[i].playerUsername);
			}
			return message;
		}

		[HarmonyPatch(typeof(HUDManager), "AddChatMessage")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchHUDManagerAddChatMessage(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching HUDManager->AddChatMessage...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo method = typeof(LobbySizePatches).GetMethod("ChatReplace", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Callvirt && list[i].operand.ToString().Contains("ToString"))
				{
					Plugin.Log.LogDebug((object)"Adding LobbySizePatches->ChatReplace");
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)method));
					i++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched HUDManager->AddChatMessage!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(SoundManager), "SetPlayerVoiceFilters")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSetPlayerVoiceFilters(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching SoundManager->SetPlayerVoiceFilters...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "UnityEngine.Audio.AudioMixer diageticMixer")
				{
					Plugin.Log.LogDebug((object)"Replacing SoundManger->diageticMixer with LobbyPatches->PlayerMixer");
					list[i - 1].opcode = OpCodes.Ldsfld;
					list[i - 1].operand = PlayerMixerField;
					list.RemoveAt(i);
					i++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched SoundManager->SetPlayerVoiceFilters!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(SoundManager), "Start")]
		[HarmonyPrefix]
		public static bool ChangeMixerSetting()
		{
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				Plugin.Log.LogInfo((object)("Changing audio mixer and expanding voice chat slots for " + lobbySize + " players."));
				if ((Object)(object)OriginalMixer == (Object)null)
				{
					OriginalMixer = SoundManager.Instance.diageticMixer;
				}
				AudioMixer newAudioMixer = NewAudioMixer32;
				newAudioMixer = ((lobbySize > 28) ? NewAudioMixer32 : ((lobbySize > 24) ? NewAudioMixer28 : ((lobbySize > 20) ? NewAudioMixer24 : ((lobbySize > 16) ? NewAudioMixer20 : ((lobbySize > 12) ? NewAudioMixer16 : ((lobbySize > 8) ? NewAudioMixer12 : ((lobbySize <= 4) ? NewAudioMixer4 : NewAudioMixer8)))))));
				Plugin.Log.LogInfo((object)("New AudioMixer: " + ((Object)newAudioMixer).name));
				newAudioMixer.outputAudioMixerGroup = OriginalMixer.FindMatchingGroups("Master")[0];
				PlayerMixer = newAudioMixer;
				float[] array = new float[lobbySize];
				float[] array2 = new float[lobbySize];
				float[] array3 = new float[lobbySize];
				float[] array4 = new float[lobbySize];
				AudioMixerGroup[] array5 = (AudioMixerGroup[])(object)new AudioMixerGroup[lobbySize];
				for (int i = 0; i < lobbySize; i++)
				{
					array[i] = 1f;
					array2[i] = 1f;
					array3[i] = 0.5f;
					array4[i] = 3f;
					array5[i] = newAudioMixer.FindMatchingGroups("VoicePlayer" + i)[0];
				}
				SoundManager.Instance.playerVoicePitches = array;
				SoundManager.Instance.playerVoicePitchTargets = array2;
				SoundManager.Instance.playerVoiceVolumes = array3;
				SoundManager.Instance.playerVoicePitchLerpSpeed = array4;
				SoundManager.Instance.playerVoiceMixers = array5;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while initializing SoundManager. Disconnecting...");
				Plugin.Log.LogError((object)ex);
				if ((Object)(object)GameNetworkManager.Instance != (Object)null)
				{
					GameNetworkManager.Instance.disconnectionReasonMessage = "SoundManager initialization failed!";
					GameNetworkManager.Instance.Disconnect();
				}
			}
			return false;
		}

		[HarmonyPatch(typeof(NetworkConnectionManager), "SendConnectionRequest")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchNetworkConnectionManagerSendConnectionRequest(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching NetworkConnectionManager->SendConnectionRequest...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i].operand.ToString().Contains("SendMessage"))
				{
					Plugin.Log.LogDebug((object)"Making connection request fragmented.");
					list[i - 3].opcode = OpCodes.Ldc_I4_4;
				}
			}
			Plugin.Log.LogDebug((object)"Patched NetworkConnectionManager->SendConnectionRequest!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(ConnectionRequestMessage), "Deserialize")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchConnectionRequestMessageDeserialize(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching ConnectionRequestMessage->Deserialize...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Callvirt && list[i].operand.ToString().Contains("CompareConfig"))
				{
					Plugin.Log.LogDebug((object)"Skipping config mismatch as we handle this ourself.");
					list[i + 1].opcode = OpCodes.Br;
					list.Insert(i + 1, new CodeInstruction(OpCodes.Pop, (object)null));
					i++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched ConnectionRequestMessage->Deserialize!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(NetworkConnectionManager), "HandleConnectionApproval")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchNetworkConnectionManagerHandleConnectionApproval(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching NetworkConnectionManager->HandleConnectionApproval...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i].operand.ToString().Contains("SendMessage") && list[i - 2].opcode == OpCodes.Ldc_I4_2)
				{
					Plugin.Log.LogDebug((object)"Making message fragmented.");
					list[i - 2].opcode = OpCodes.Ldc_I4_4;
				}
			}
			Plugin.Log.LogDebug((object)"Patched NetworkConnectionManager->HandleConnectionApproval!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "LeaveLobbyAtGameStart")]
		[HarmonyPrefix]
		private static bool LeaveLobbyAtGameStart(GameNetworkManager __instance)
		{
			//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)
			AdvancedCompany.Network.Manager.Lobby.IsJoinable = false;
			if (ServerConfiguration.Instance.Lobby.KeepOpen)
			{
				if (NetworkManager.Singleton.IsServer && !ServerConfiguration.Instance.Lobby.KeepOpenOnMoon && __instance.currentLobby.HasValue && __instance.currentLobby.HasValue)
				{
					Lobby value = __instance.currentLobby.Value;
					((Lobby)(ref value)).SetJoinable(false);
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(NetworkConnectionManager), "ApproveConnection")]
		[HarmonyPostfix]
		private static void ApproveConnection(NetworkConnectionManager __instance, ref ConnectionRequestMessage connectionRequestMessage, ref NetworkContext context)
		{
			if (ConnectingClients.ContainsKey(context.SenderId) && ConnectingClients[context.SenderId].Error != null)
			{
				__instance.ClientsToApprove[context.SenderId].Approved = false;
				__instance.ClientsToApprove[context.SenderId].Reason = ConnectingClients[context.SenderId].Error;
				ConnectingClients[context.SenderId].IsFinished = true;
				ConnectingClients.Remove(context.SenderId);
			}
		}

		[HarmonyPatch(typeof(ConnectionApprovedMessage), "Serialize")]
		[HarmonyPostfix]
		private unsafe static void WriteLobbyData(ConnectionApprovedMessage __instance, ref FastBufferWriter writer, int targetVersion)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!ConnectingClients.ContainsKey(__instance.OwnerClientId))
			{
				return;
			}
			Plugin.Log.LogInfo((object)"Adding data to ConnectionApprovedMessage.");
			Sync sync = ConnectingClients[__instance.OwnerClientId];
			int position = ((FastBufferWriter)(ref writer)).Position;
			sync.WriteDataToPlayerJoiningLobby(writer);
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref position, default(ForPrimitives));
			byte[] array = ((FastBufferWriter)(ref writer)).ToArray();
			using (MemoryStream memoryStream2 = new MemoryStream(array))
			{
				using MemoryStream memoryStream = new MemoryStream();
				using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Compress))
				{
					memoryStream2.CopyTo(gZipStream);
					gZipStream.Flush();
				}
				array = memoryStream.ToArray();
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(array.Length, (Allocator)2, -1);
			((FastBufferWriter)(ref val)).WriteBytesSafe(array, array.Length, 0);
			SwitchHandles(ref writer.Handle, ref val.Handle);
			((FastBufferWriter)(ref val)).Dispose();
		}

		private unsafe static void SwitchHandles(ref WriterHandle* handleA, ref WriterHandle* handleB)
		{
			//IL_0003: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Allocator allocator = ((WriterHandle)handleB).Allocator;
			bool bufferGrew = ((WriterHandle)handleB).BufferGrew;
			byte* bufferPointer = ((WriterHandle)handleB).BufferPointer;
			int capacity = ((WriterHandle)handleB).Capacity;
			int length = ((WriterHandle)handleB).Length;
			int maxCapacity = ((WriterHandle)handleB).MaxCapacity;
			int position = ((WriterHandle)handleB).Position;
			Unsafe.Write(&((WriterHandle)handleB).Allocator, ((WriterHandle)handleA).Allocator);
			((WriterHandle)handleB).BufferGrew = ((WriterHandle)handleA).BufferGrew;
			((WriterHandle)handleB).BufferPointer = ((WriterHandle)handleA).BufferPointer;
			((WriterHandle)handleB).Capacity = ((WriterHandle)handleA).Capacity;
			((WriterHandle)handleB).Length = ((WriterHandle)handleA).Length;
			((WriterHandle)handleB).MaxCapacity = ((WriterHandle)handleA).MaxCapacity;
			((WriterHandle)handleB).Position = ((WriterHandle)handleA).Position;
			Unsafe.Write(&((WriterHandle)handleA).Allocator, allocator);
			((WriterHandle)handleA).BufferGrew = bufferGrew;
			((WriterHandle)handleA).BufferPointer = bufferPointer;
			((WriterHandle)handleA).Capacity = capacity;
			((WriterHandle)handleA).Length = length;
			((WriterHandle)handleA).MaxCapacity = maxCapacity;
			((WriterHandle)handleA).Position = position;
		}

		[HarmonyPatch(typeof(ConnectionApprovedMessage), "Deserialize")]
		[HarmonyPrefix]
		private static void DecodeLobbyData(ConnectionApprovedMessage __instance, ref bool __result, ref FastBufferReader reader, NetworkContext context, int receivedMessageVersion)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogDebug((object)("Len: " + ((FastBufferReader)(ref reader)).Length));
			byte[] array = new byte[((FastBufferReader)(ref reader)).Length];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref array, ((FastBufferReader)(ref reader)).Length, 0);
			for (int i = 0; i < 32; i++)
			{
				Plugin.Log.LogMessage((object)array[i]);
			}
			using (MemoryStream stream = new MemoryStream(array))
			{
				using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
				using MemoryStream memoryStream = new MemoryStream();
				gZipStream.CopyTo(memoryStream);
				array = memoryStream.ToArray();
			}
			reader = new FastBufferReader(array, (Allocator)2, array.Length, 0);
		}

		[HarmonyPatch(typeof(ConnectionApprovedMessage), "Deserialize")]
		[HarmonyPostfix]
		private static void ReadLobbyData(ConnectionApprovedMessage __instance, ref bool __result, FastBufferReader reader, NetworkContext context, int receivedMessageVersion)
		{
			//IL_003d: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			if (__result)
			{
				AdvancedCompany.Game.Player.Reset();
				Plugin.Log.LogMessage((object)"Reading ApprovedMessage.");
				int position = ((FastBufferReader)(ref reader)).Position;
				((FastBufferReader)(ref reader)).Seek(((FastBufferReader)(ref reader)).Length - 4);
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferReader)(ref reader)).Seek(num);
				Handshake.ReadDataFromJoiningLobby(reader);
				((FastBufferReader)(ref reader)).Seek(position);
			}
		}

		[HarmonyPatch(typeof(ConnectionRequestMessage), "Serialize")]
		[HarmonyPostfix]
		private static void WriteConnectData(ConnectionRequestMessage __instance, FastBufferWriter writer, int targetVersion)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Doing a handshake with the server.");
			Handshake = new Sync();
			Handshake.WriteDataToHostBeforeJoining(writer);
		}

		[HarmonyPatch(typeof(ConnectionRequestMessage), "Deserialize")]
		[HarmonyPostfix]
		private static void ReadConnectData(ConnectionRequestMessage __instance, ref bool __result, FastBufferReader reader, NetworkContext context, int receivedMessageVersion)
		{
			//IL_0001: 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_000d: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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)
			NetworkManager val = (NetworkManager)context.SystemOwner;
			Sync sync = new Sync();
			sync.ClientId = context.SenderId;
			sync.ConfigHash = __instance.ConfigHash;
			ConnectingClients.Add(context.SenderId, sync);
			try
			{
				if (!__result)
				{
					return;
				}
				if (((FastBufferReader)(ref reader)).Length > ((FastBufferReader)(ref reader)).Position)
				{
					if ((AdvancedCompany.Network.Manager.Lobby.IsJoinable || ServerConfiguration.Instance.Lobby.KeepOpenOnMoon) && (!GameNetworkManager.Instance.gameHasStarted || ServerConfiguration.Instance.Lobby.KeepOpen))
					{
						sync.ReadDataFromClientBeforeJoining(reader);
					}
					else
					{
						sync.SetError("Lobby is currently not joinable. Game has started.");
					}
				}
				else
				{
					sync.SetError("Missing AdvancedCompany mod.");
					Plugin.Log.LogWarning((object)"Client is missing AdvancedCompany!");
				}
			}
			catch (Exception ex)
			{
				sync.SetError("Unknown error");
				Plugin.Log.LogError((object)"Unknown error while connecting:");
				Plugin.Log.LogError((object)ex.ToString());
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SteamMatchmaking_OnLobbyCreated")]
		[HarmonyPrefix]
		private static void SteamMatchmaking_OnLobbyCreated(GameNetworkManager __instance, Result result, Lobby lobby)
		{
			((Lobby)(ref lobby)).SetData("advcmpny", Mod.GetHash());
		}

		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		[HarmonyPostfix]
		private static void GameNetworkManagerConnectionApproval(GameNetworkManager __instance, ConnectionApprovalRequest request, ConnectionApprovalResponse response)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if (!ServerConfiguration.Instance.Lobby.KeepOpen && (__instance.gameHasStarted || !AdvancedCompany.Network.Manager.Lobby.IsJoinable))
			{
				response.Reason = "Game has already started!";
				response.Approved = false;
			}
			else if (ConnectingClients.ContainsKey(request.ClientNetworkId) && response.Approved)
			{
				Plugin.Log.LogInfo((object)("Connecting client added to queue... Currently there are " + ConnectingClients.Count + " clients connecting..."));
				response.Pending = true;
				ConnectingClients[request.ClientNetworkId].Response = response;
				PendingRequests.Add(ConnectingClients[request.ClientNetworkId]);
			}
		}

		[HarmonyPatch(typeof(RoundManager), "Update")]
		[HarmonyPostfix]
		private static void WorkQueue()
		{
			if (PendingRequests.Count > 0)
			{
				Sync sync = PendingRequests[0];
				sync.Response.Pending = false;
				if (sync.IsFinished)
				{
					Plugin.Log.LogInfo((object)("Client finished. Working on connection queue. Pending clients: " + PendingRequests.Count));
					PendingRequests.RemoveAt(0);
				}
			}
		}

		[HarmonyPatch(typeof(QuickMenuManager), "InviteFriendsButton")]
		[HarmonyPrefix]
		private static bool QuickMenuManagerInviteFriendsButton(QuickMenuManager __instance)
		{
			if (ServerConfiguration.Instance.Lobby.KeepOpenOnMoon)
			{
				GameNetworkManager.Instance.InviteFriendsUI();
				return false;
			}
			if (ServerConfiguration.Instance.Lobby.KeepOpen)
			{
				if (AdvancedCompany.Network.Manager.Lobby.IsJoinable)
				{
					GameNetworkManager.Instance.InviteFriendsUI();
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void openingDoorsSequenceCloseLobby(StartOfRound __instance)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			AdvancedCompany.Network.Manager.Lobby.IsJoinable = false;
			if (!ServerConfiguration.Instance.Lobby.KeepOpenOnMoon && GameNetworkManager.Instance.currentLobby.HasValue && GameNetworkManager.Instance.currentLobby.HasValue)
			{
				Lobby value = GameNetworkManager.Instance.currentLobby.Value;
				((Lobby)(ref value)).SetJoinable(false);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "StartGame")]
		[HarmonyPrefix]
		private static void StartOfRoundStartGame(StartOfRound __instance)
		{
			AdvancedCompany.Network.Manager.Lobby.IsJoinable = false;
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		[HarmonyPrefix]
		private static void StartOfRoundReviveDeadPlayers(StartOfRound __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			AdvancedCompany.Network.Manager.Lobby.IsJoinable = true;
			if (ServerConfiguration.Instance.Lobby.KeepOpen && GameNetworkManager.Instance.currentLobby.HasValue && GameNetworkManager.Instance.currentLobby.HasValue)
			{
				Lobby value = GameNetworkManager.Instance.currentLobby.Value;
				((Lobby)(ref value)).SetJoinable(true);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientConnectedCallback")]
		[HarmonyPostfix]
		private static void Singleton_OnClientConnectedCallback()
		{
			if (Handshake != null)
			{
				Handshake.NetworkObjectsPlaced();
			}
		}

		[HarmonyPatch(typeof(NetworkSceneManager), "PopulateScenePlacedObjects")]
		[HarmonyPostfix]
		private static void CreatePlayers(NetworkSceneManager __instance)
		{
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			try
			{
				Plugin.Log.LogMessage((object)"PopulateScenePlacedObjects");
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				Plugin.Log.LogInfo((object)("Extending Lobby. Adding new player objects for a lobby size of " + lobbySize));
				Dictionary<uint, Dictionary<int, NetworkObject>> scenePlacedObjects = (Dictionary<uint, Dictionary<int, NetworkObject>>)NetworkSceneManagerScenePlacedObjects.GetValue(__instance);
				StartOfRound instance = StartOfRound.Instance;
				SoundManager instance2 = SoundManager.Instance;
				if (instance.allPlayerScripts.Length >= lobbySize)
				{
					return;
				}
				int num = instance.allPlayerObjects.Length;
				PlayerControllerB[] array = (PlayerControllerB[])(object)new PlayerControllerB[lobbySize];
				GameObject[] array2 = (GameObject[])(object)new GameObject[lobbySize];
				PlayerStats[] array3 = (PlayerStats[])(object)new PlayerStats[lobbySize];
				Transform[] array4 = (Transform[])(object)new Transform[lobbySize];
				Array.Copy(instance.allPlayerScripts, 0, array, 0, instance.allPlayerScripts.Length);
				Array.Copy(instance.allPlayerObjects, 0, array2, 0, instance.allPlayerObjects.Length);
				Array.Copy(instance.gameStats.allPlayerStats, 0, array3, 0, instance.gameStats.allPlayerStats.Length);
				Array.Copy(instance.playerSpawnPositions, 0, array4, 0, instance.playerSpawnPositions.Length);
				GameObject val = instance.allPlayerObjects[instance.allPlayerObjects.Length - 1];
				uint arg = 12345u;
				val.SetActive(false);
				Func<uint, NetworkObject, uint> func = delegate(uint hash, NetworkObject networkObject)
				{
					//IL_004f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0054: 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_007f: Unknown result type (might be due to invalid IL or missing references)
					while (scenePlacedObjects.ContainsKey(hash))
					{
						hash++;
					}
					if (!scenePlacedObjects.ContainsKey(hash))
					{
						scenePlacedObjects.Add(hash, new Dictionary<int, NetworkObject>());
					}
					Dictionary<int, NetworkObject> dictionary = scenePlacedObjects[hash];
					Scene scene = ((Component)networkObject).gameObject.scene;
					if (!dictionary.ContainsKey(((Scene)(ref scene)).handle))
					{
						Dictionary<int, NetworkObject> dictionary2 = scenePlacedObjects[hash];
						scene = ((Component)networkObject).gameObject.scene;
						dictionary2.Add(((Scene)(ref scene)).handle, networkObject);
					}
					networkObject.GlobalObjectIdHash = hash;
					return hash + 1;
				};
				for (int i = num; i < lobbySize; i++)
				{
					GameObject val2 = Object.Instantiate<GameObject>(val, val.transform.parent);
					PlayerControllerB component = val2.GetComponent<PlayerControllerB>();
					NetworkObject component2 = val2.GetComponent<NetworkObject>();
					NetworkObject component3 = ((Component)val2.transform.Find("PlayerPhysicsBox")).GetComponent<NetworkObject>();
					NetworkObject component4 = ((Component)val2.transform.Find("ScavengerModel/metarig/ScavengerModelArmsOnly/metarig/spine.003/shoulder.R/arm.R_upper/arm.R_lower/hand.R/LocalItemHolder")).GetComponent<NetworkObject>();
					NetworkObject component5 = ((Component)val2.transform.Find("ScavengerModel/metarig/spine/spine.001/spine.002/spine.003/shoulder.R/arm.R_upper/arm.R_lower/hand.R/ServerItemHolder")).GetComponent<NetworkObject>();
					arg = func(arg, component2);
					arg = func(arg, component3);
					arg = func(arg, component4);
					arg = func(arg, component5);
					((Object)val2).name = "Player (" + i + ")";
					component.playerClientId = (ulong)i;
					component.playerUsername = "Player #" + (i + 1);
					array2[i] = val2;
					array[i] = component;
					array3[i] = new PlayerStats();
					array4[i] = array4[3];
					StartOfRound.Instance.mapScreen.radarTargets.Add(new TransformAndName(val2.transform, component.playerUsername, false));
					arg += 4;
				}
				val.SetActive(true);
				instance.allPlayerScripts = array;
				instance.allPlayerObjects = array2;
				instance.playerSpawnPositions = array4;
				instance.gameStats.allPlayerStats = array3;
				for (int j = 0; j < lobbySize; j++)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(instance.allPlayerScripts[j]);
					if (player.Username == null || player.Username == "")
					{
						player.Username = instance.allPlayerScripts[j].playerUsername;
					}
					player.RadarTarget = StartOfRound.Instance.mapScreen.radarTargets[j];
					instance.allPlayerObjects[j].SetActive(true);
				}
				if (NetworkManager.Singleton.IsServer)
				{
					((MonoBehaviour)instance).StartCoroutine(DeactivatePlayerObjectsNextFrame());
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending Lobby:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending Lobby.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(ForestGiantAI), "Start")]
		[HarmonyPrefix]
		private static void ForestGiantStart(ForestGiantAI __instance)
		{
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				Plugin.Log.LogInfo((object)("Extending ForestGiantAI->playerSteahlMeters for " + lobbySize + " players."));
				__instance.playerStealthMeters = new float[lobbySize];
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending ForestGiantAI:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending ForestGiantAI.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(CrawlerAI), "Start")]
		[HarmonyPostfix]
		private static void CrawlerAIStart(CrawlerAI __instance)
		{
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				Plugin.Log.LogInfo((object)("Extending CrawlerAI->nearPlayerColliders for " + lobbySize + " players."));
				CrawlerAINearPlayerColliders.SetValue(__instance, new Collider[lobbySize]);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending CrawlerAI:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending CrawlerAI.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(ShipTeleporter), "Awake")]
		[HarmonyPostfix]
		private static void ShipTeleporterAwake(ShipTeleporter __instance)
		{
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				Plugin.Log.LogInfo((object)("Extending ShipTeleporter->playersBeingTeleported for " + lobbySize + " players."));
				int[] array = new int[lobbySize];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = -1;
				}
				ShipTeleporterPlayersBeingTeleported.SetValue(__instance, array);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending ShipTeleporter:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending ShipTeleporter.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(QuickMenuManager), "Start")]
		[HarmonyPrefix]
		private static void ReworkQuickMenuManagerUI(QuickMenuManager __instance)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Expected O, but got Unknown
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				if (__instance.playerListSlots.Length >= lobbySize)
				{
					return;
				}
				Plugin.Log.LogInfo((object)("Extending QuickMenuManager player slots for " + lobbySize + " players."));
				PlayerListSlot[] array = (PlayerListSlot[])(object)new PlayerListSlot[lobbySize];
				Transform child = __instance.playerListPanel.transform.GetChild(0);
				GameObject val = Object.Instantiate<GameObject>(ScrollViewPrefab, child);
				RectTransform component = ((Component)val.transform).GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 0f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0f, 1f);
				component.offsetMax = new Vector2(-1f, -40f);
				component.offsetMin = new Vector2(0f, 1.5f);
				val.GetComponent<ScrollRect>().movementType = (MovementType)2;
				GameObject gameObject = ((Component)val.transform.GetChild(0).GetChild(0)).gameObject;
				VerticalLayoutGroup val2 = gameObject.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)val2).childAlignment = (TextAnchor)0;
				((HorizontalOrVerticalLayoutGroup)val2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)val2).childControlWidth = false;
				((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
				((LayoutGroup)val2).padding = new RectOffset(10, 0, 50, -30);
				ContentSizeFitter val3 = gameObject.AddComponent<ContentSizeFitter>();
				val3.verticalFit = (FitMode)1;
				for (int i = 0; i < lobbySize; i++)
				{
					Transform transform = Object.Instantiate<GameObject>(((Component)child.GetChild(1)).gameObject, gameObject.transform).transform;
					transform.parent = gameObject.transform;
					RectTransform component2 = ((Component)transform).GetComponent<RectTransform>();
					component2.sizeDelta = new Vector2(200f, 50f);
					component2.pivot = new Vector2(0f, 0f);
					GameObject gameObject2 = ((Component)transform.GetChild(3)).gameObject;
					int playerNum = i;
					((UnityEvent)gameObject2.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						__instance.KickUserFromServer(playerNum);
					});
					GameObject gameObject3 = ((Component)transform.GetChild(2)).gameObject;
					((UnityEvent)gameObject3.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
					{
						__instance.OpenUserSteamProfile(playerNum);
					});
					array[i] = new PlayerListSlot
					{
						slotContainer = ((Component)transform).gameObject,
						volumeSliderContainer = ((Component)transform.GetChild(1)).gameObject,
						KickUserButton = ((Component)transform.GetChild(3)).gameObject,
						usernameHeader = ((Component)transform.GetChild(0).GetChild(0)).GetComponent<TextMeshProUGUI>(),
						volumeSlider = ((Component)transform.GetChild(1).GetChild(1)).GetComponent<Slider>(),
						isConnected = (__instance.playerListSlots.Length > i && __instance.playerListSlots[i].isConnected),
						playerSteamId = ((__instance.playerListSlots.Length > i) ? __instance.playerListSlots[i].playerSteamId : 0)
					};
				}
				for (int j = 0; j < child.childCount; j++)
				{
					Transform child2 = child.GetChild(j);
					if (((Object)child2).name.StartsWith("PlayerListSlot"))
					{
						((Component)child2).gameObject.SetActive(false);
					}
				}
				__instance.playerListSlots = array;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending QuickMenuManager:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending QuickMenuManager.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(HUDManager), "Start")]
		[HarmonyPrefix]
		private static void FixEndscreen(HUDManager __instance)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			try
			{
				int lobbySize = ServerConfiguration.Instance.Lobby.LobbySize;
				if (__instance.statsUIElements.playerStates.Length < lobbySize)
				{
					Plugin.Log.LogInfo((object)("Extending HUDManager stats for " + lobbySize + " players."));
					Image[] array = (Image[])(object)new Image[lobbySize];
					TextMeshProUGUI[] array2 = (TextMeshProUGUI[])(object)new TextMeshProUGUI[lobbySize];
					TextMeshProUGUI[] array3 = (TextMeshProUGUI[])(object)new TextMeshProUGUI[lobbySize];
					Array.Copy(__instance.statsUIElements.playerStates, 0, array, 0, __instance.statsUIElements.playerStates.Length);
					Array.Copy(__instance.statsUIElements.playerNotesText, 0, array2, 0, __instance.statsUIElements.playerNotesText.Length);
					Array.Copy(__instance.statsUIElements.playerNamesText, 0, array3, 0, __instance.statsUIElements.playerNamesText.Length);
					for (int i = __instance.statsUIElements.playerStates.Length; i < lobbySize; i++)
					{
						GameObject val = new GameObject("dummyImage" + i);
						val.transform.parent = ((Component)__instance.endgameStatsAnimator).transform;
						Image val2 = val.AddComponent<Image>();
						val.SetActive(false);
						val = new GameObject("dummyNotes" + i);
						val.transform.parent = ((Component)__instance.endgameStatsAnimator).transform;
						TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
						val.SetActive(false);
						val = new GameObject("dummyName" + i);
						val.transform.parent = ((Component)__instance.endgameStatsAnimator).transform;
						TextMeshProUGUI val4 = val.AddComponent<TextMeshProUGUI>();
						val.SetActive(false);
						array[i] = val2;
						array3[i] = val4;
						array2[i] = val3;
					}
					__instance.statsUIElements.playerNotesText = array2;
					__instance.statsUIElements.playerStates = array;
					__instance.statsUIElements.playerNamesText = array3;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while extending HUDManager to lobby size.");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while extending HUDManager.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		[HarmonyPatch(typeof(InteractTrigger), "StopSpecialAnimation")]
		[HarmonyPrefix]
		private static bool InteractTriggerStopSpecialAnimation(InteractTrigger __instance)
		{
			if ((Object)(object)__instance.lockedPlayer != (Object)null)
			{
				PlayerControllerB component = ((Component)__instance.lockedPlayer).GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)null && component.isPlayerDead)
				{
					return false;
				}
			}
			return true;
		}

		public static IEnumerator DeactivatePlayerObjectsNextFrame()
		{
			yield return (object)new WaitForEndOfFrame();
			yield return (object)new WaitForEndOfFrame();
			ActivatePlayerObjects(StartOfRound.Instance, new ulong[1]);
		}

		[HarmonyPatch(typeof(HUDManager), "FillEndGameStats")]
		[HarmonyPrefix]
		private static void HUDManagerFillEndGameStats(HUDManager __instance)
		{
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DisablePlayerModel")]
		[HarmonyPostfix]
		private static void DisablePlayerModel(PlayerControllerB __instance, GameObject playerObject, bool enable = false, bool disableLocalArms = false)
		{
			if (!enable)
			{
				AdvancedCompany.Game.Player.GetPlayer(__instance).HideCosmetics();
			}
			else
			{
				AdvancedCompany.Game.Player.GetPlayer(__instance).ShowCosmetics();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")]
		[HarmonyPostfix]
		private static void SendNewPlayerValuesClientRpc(PlayerControllerB __instance)
		{
			if (GameNetworkManager.Instance.disableSteam)
			{
				return;
			}
			for (int i = 0; i < StartOfRound.Instance.mapScreen.radarTargets.Count; i++)
			{
				TransformAndName val = StartOfRound.Instance.mapScreen.radarTargets[i];
				for (int j = 0; j < StartOfRound.Instance.allPlayerObjects.Length; j++)
				{
					if ((Object)(object)val.transform == (Object)(object)StartOfRound.Instance.allPlayerObjects[j].transform)
					{
						val.name = StartOfRound.Instance.allPlayerScripts[j].playerUsername ?? "";
					}
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerConnectedClientRpc")]
		[HarmonyPostfix]
		private static void OnPlayerConnectedClientRpc(StartOfRound __instance, ulong clientId, int connectedPlayers, ulong[] connectedPlayerIdsOrdered, int assignedPlayerObjectId, int serverMoneyAmount, int levelID, int profitQuota, int timeUntilDeadline, int quotaFulfilled, int randomSeed)
		{
			ActivatePlayerObjects(__instance, connectedPlayerIdsOrdered);
			if (clientId != NetworkManager.Singleton.LocalClientId)
			{
				if (!AdvancedCompany.Network.Manager.Lobby.IsJoinable)
				{
					__instance.allPlayerScripts[assignedPlayerObjectId].DisablePlayerModel(((Component)__instance.allPlayerScripts[assignedPlayerObjectId]).gameObject, false, true);
				}
				else
				{
					__instance.allPlayerScripts[assignedPlayerObjectId].DisablePlayerModel(((Component)__instance.allPlayerScripts[assignedPlayerObjectId]).gameObject, true, true);
				}
			}
			__instance.allPlayerScripts[assignedPlayerObjectId].disconnectedMidGame = false;
			int num = 0;
			for (int i = 0; i < __instance.allPlayerScripts.Length; i++)
			{
				if (i == 0)
				{
					if (!__instance.allPlayerScripts[i].isPlayerDead)
					{
						num++;
					}
					continue;
				}
				bool flag = i == assignedPlayerObjectId || (!((NetworkBehaviour)__instance.allPlayerScripts[i]).IsOwnedByServer && !__instance.allPlayerScripts[i].isPlayerDead && connectedPlayerIdsOrdered[i] != 999);
				__instance.allPlayerScripts[i].isPlayerControlled = flag;
				if (connectedPlayerIdsOrdered[i] != 999)
				{
					__instance.allPlayerScripts[i].actualClientId = connectedPlayerIdsOrdered[i];
				}
				if (flag)
				{
					num++;
				}
			}
			if (GameNetworkManager.Instance.disableSteam)
			{
				for (int j = 0; j < StartOfRound.Instance.mapScreen.radarTargets.Count; j++)
				{
					TransformAndName val = StartOfRound.Instance.mapScreen.radarTargets[j];
					for (int k = 0; k < StartOfRound.Instance.allPlayerObjects.Length; k++)
					{
						if ((Object)(object)val.transform == (Object)(object)StartOfRound.Instance.allPlayerObjects[k].transform)
						{
							val.name = StartOfRound.Instance.allPlayerScripts[k].playerUsername ?? "";
						}
					}
				}
			}
			__instance.livingPlayers = num;
			for (int l = 0; l < StartOfRound.Instance.allPlayerScripts.Length; l++)
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(StartOfRound.Instance.allPlayerScripts[l]);
				player?.SetCosmetics(player.Cosmetics, sendMessage: false);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
		[HarmonyPostfix]
		private static void OnPlayerDC(StartOfRound __instance, int playerObjectNumber, ulong clientId)
		{
			try
			{
				Plugin.Log.LogInfo((object)("Player (" + playerObjectNumber + ") disconnected. Changing activation state of player objects."));
				AdvancedCompany.Network.Manager.Lobby.PlayerDisconnected(playerObjectNumber);
				List<int> list = __instance.ClientPlayerList.Values.ToList();
				ulong[] array = new ulong[ServerConfiguration.Instance.Lobby.LobbySize];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = (ulong)(int)(list.Contains(i) ? ((uint)i) : 999u);
				}
				ActivatePlayerObjects(__instance, array);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while activating player objects:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while activating player objects.";
				GameNetworkManager.Instance.Disconnect();
			}
		}

		private static void ActivatePlayerObjects(StartOfRound __instance, ulong[] connectedPlayerIdsOrdered)
		{
			try
			{
				ConnectedIDs = new List<ulong>();
				Plugin.Log.LogInfo((object)"Activating necessary player objects for next player to join.");
				bool flag = true;
				for (int i = 0; i < __instance.allPlayerObjects.Length; i++)
				{
					if (connectedPlayerIdsOrdered.Length > i && connectedPlayerIdsOrdered[i] != 999)
					{
						ConnectedIDs.Add((ulong)i);
						if (!__instance.allPlayerObjects[i].activeSelf)
						{
							__instance.allPlayerObjects[i].SetActive(true);
						}
					}
					else if (flag)
					{
						if (!__instance.allPlayerObjects[i].activeSelf)
						{
							__instance.allPlayerObjects[i].SetActive(true);
						}
						Plugin.Log.LogInfo((object)("Next player object with ID " + __instance.allPlayerScripts[i].playerClientId + " activated."));
						flag = false;
					}
					else if (__instance.allPlayerObjects[i].activeSelf)
					{
						__instance.allPlayerObjects[i].SetActive(false);
					}
				}
				if (flag)
				{
					Plugin.Log.LogInfo((object)"No remaining free player objects. Lobby is full!");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while activating player objects:");
				Plugin.Log.LogError((object)ex);
				GameNetworkManager.Instance.disconnectionReasonMessage = "Error while activating player objects.";
				GameNetworkManager.Instance.Disconnect();
			}
		}
	}
	internal class MaskedEnemyPatches
	{
		public class MaskedPlayerAdditions
		{
			public MaskedPlayerEnemy MaskedPlayer;

			public int MimickedPlayer = 9999;

			public Dictionary<string, GameObject> AppliedCosmetics = new Dictionary<string, GameObject>();

			private Dictionary<AdvancedCompany.Game.Player.Bone, Transform> Bones = new Dictionary<AdvancedCompany.Game.Player.Bone, Transform>();

			public MaskedPlayerAdditions(MaskedPlayerEnemy enemy)
			{
				MaskedPlayer = enemy;
				Plugin.Log.LogMessage((object)"Searching for bones of masked enemy.");
				FindBones(((Component)enemy).transform.Find("ScavengerModel").Find("metarig"));
			}

			public Transform GetBone(AdvancedCompany.Game.Player.Bone bone)
			{
				if (Bones.ContainsKey(bone))
				{
					return Bones[bone];
				}
				return null;
			}

			protected void FindBones(Transform transform)
			{
				for (int i = 0; i < transform.childCount; i++)
				{
					Transform child = transform.GetChild(i);
					if (!(((Object)child).name == "ScavengerModelArmsOnly"))
					{
						if (AdvancedCompany.Game.Player.BoneNames.ContainsKey(((Object)child).name))
						{
							Bones.Add(AdvancedCompany.Game.Player.BoneNames[((Object)child).name], child);
						}
						FindBones(child);
					}
				}
			}
		}

		private static Dictionary<int, MaskedPlayerAdditions> MaskedPlayers = new Dictionary<int, MaskedPlayerAdditions>();

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "Start")]
		[HarmonyPostfix]
		private static void Start(MaskedPlayerEnemy __instance)
		{
			ApplyCosmetics(__instance);
		}

		internal static void ApplyCosmetics(MaskedPlayerEnemy enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Masked enemy was null when applying cosmetics.");
				return;
			}
			int instanceID = ((Object)enemy).GetInstanceID();
			if (!MaskedPlayers.ContainsKey(instanceID))
			{
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, MaskedPlayerAdditions> maskedPlayer in MaskedPlayers)
				{
					if ((Object)(object)maskedPlayer.Value.MaskedPlayer == (Object)null)
					{
						Plugin.Log.LogMessage((object)"Removing deleted masked player from cache.");
						list.Add(maskedPlayer.Key);
					}
				}
				foreach (int item in list)
				{
					MaskedPlayers.Remove(item);
				}
				if (!MaskedPlayers.ContainsKey(instanceID))
				{
					MaskedPlayers.Add(instanceID, new MaskedPlayerAdditions(enemy));
				}
			}
			MaskedPlayerAdditions maskedPlayerAdditions = MaskedPlayers[instanceID];
			if ((Object)(object)enemy.mimickingPlayer != (Object)null)
			{
				if ((int)enemy.mimickingPlayer.playerClientId == maskedPlayerAdditions.MimickedPlayer)
				{
					return;
				}
				Plugin.Log.LogMessage((object)("Masked player is mimicking player " + enemy.mimickingPlayer.playerClientId + "."));
				enemy.SetSuit(enemy.mimickingPlayer.currentSuitID);
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(enemy.mimickingPlayer);
				maskedPlayerAdditions.MimickedPlayer = player.PlayerNum;
				Plugin.Log.LogMessage((object)("Cosmetics of player: " + string.Join(", ", player.Cosmetics)));
				List<string> list2 = new List<string>();
				List<string> list3 = new List<string>();
				foreach (KeyValuePair<string, GameObject> appliedCosmetic in maskedPlayerAdditions.AppliedCosmetics)
				{
					if (!player.Cosmetics.Contains(appliedCosmetic.Key))
					{
						list2.Add(appliedCosmetic.Key);
					}
				}
				string[] cosmetics = player.Cosmetics;
				foreach (string text in cosmetics)
				{
					if (!maskedPlayerAdditions.AppliedCosmetics.ContainsKey(text))
					{
						list3.Add(text);
					}
				}
				for (int j = 0; j < list2.Count; j++)
				{
					Object.Destroy((Object)(object)maskedPlayerAdditions.AppliedCosmetics[list2[j]]);
					maskedPlayerAdditions.AppliedCosmetics.Remove(list2[j]);
				}
				for (int k = 0; k < list3.Count; k++)
				{
					AddCosmetic(maskedPlayerAdditions, list3[k]);
				}
				return;
			}
			Plugin.Log.LogMessage((object)"MaskedPlayer is not mimicking anyone.");
			if (maskedPlayerAdditions.MimickedPlayer == 9999)
			{
				return;
			}
			Plugin.Log.LogMessage((object)"Removing all cosmetics");
			maskedPlayerAdditions.MimickedPlayer = 9999;
			foreach (KeyValuePair<string, GameObject> appliedCosmetic2 in maskedPlayerAdditions.AppliedCosmetics)
			{
				Object.Destroy((Object)(object)appliedCosmetic2.Value);
			}
			maskedPlayerAdditions.AppliedCosmetics = new Dictionary<string, GameObject>();
		}

		internal static void AddCosmetic(MaskedPlayerAdditions maskedPlayer, string cosmeticID)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (CosmeticDatabase.AllCosmetics.ContainsKey(cosmeticID))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)CosmeticDatabase.AllCosmetics[cosmeticID]).gameObject);
				CosmeticInstance component = val.GetComponent<CosmeticInstance>();
				Transform val2 = null;
				switch (component.cosmeticType)
				{
				case CosmeticType.HAT:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_3);
					break;
				case CosmeticType.CHEST:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_2);
					break;
				case CosmeticType.HIP:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_0);
					break;
				case CosmeticType.R_LOWER_ARM:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.R_LOWER_ARM);
					break;
				case CosmeticType.L_SHIN:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.L_SHIN);
					break;
				case CosmeticType.R_SHIN:
					val2 = maskedPlayer.GetBone(AdvancedCompany.Game.Player.Bone.R_SHIN);
					break;
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Log.LogWarning((object)"Bone was null!");
					return;
				}
				val.transform.position = val2.position;
				val.transform.rotation = val2.rotation;
				Transform transform = val.transform;
				transform.localScale *= 0.38f;
				val.transform.parent = val2;
				maskedPlayer.AppliedCosmetics.Add(cosmeticID, val);
			}
		}
	}
	[HarmonyPatch]
	internal class NoLobbyPatches
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void AddPlayers()
		{
			for (int i = 0; i < StartOfRound.Instance.allPlayerObjects.Length; i++)
			{
				AdvancedCompany.Game.Player.GetPlayer(StartOfRound.Instance.allPlayerScripts[i]);
			}
		}
	}
	[HarmonyPatch]
	internal class PlayerControllerB
	{
		private static Dictionary<ulong, AnimatorOverrideController> Animators = new Dictionary<ulong, AnimatorOverrideController>();

		private static Dictionary<ulong, AnimationClipOverrides> Overrides = new Dictionary<ulong, AnimationClipOverrides>();

		private static float OriginalJumpForce = 13f;

		private static bool Initialized = false;

		public static Dictionary<ulong, Texture2D> PlayerAvatars = new Dictionary<ulong, Texture2D>();

		public static Dictionary<ulong, Task<Image?>> LoadingAvatars = new Dictionary<ulong, Task<Image?>>();

		[HarmonyPatch(typeof(PlayerControllerB), "OnEnable")]
		[HarmonyPostfix]
		public static void OnEnable(PlayerControllerB __instance)
		{
			if ((Object)(object)((Component)__instance).gameObject.GetComponent<PlayerRocketBoots>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<PlayerRocketBoots>();
			}
		}

		public static Texture2D GetAvatar(PlayerControllerB player)
		{
			if (PlayerAvatars.ContainsKey(player.playerSteamId))
			{
				return PlayerAvatars[player.playerSteamId];
			}
			return null;
		}

		private static void LoadAvatar(PlayerControllerB player)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			ulong playerSteamId = player.playerSteamId;
			if (playerSteamId != 0 && SteamClient.IsValid && !PlayerAvatars.ContainsKey(playerSteamId))
			{
				if (!LoadingAvatars.ContainsKey(playerSteamId))
				{
					LoadingAvatars.Add(playerSteamId, SteamFriends.GetLargeAvatarAsync(SteamId.op_Implicit(playerSteamId)));
				}
				else if (LoadingAvatars[playerSteamId].IsCompletedSuccessfully)
				{
					PlayerAvatars.Add(playerSteamId, GetTextureFromImage(LoadingAvatars[playerSteamId].Result));
				}
				else if (LoadingAvatars[playerSteamId].IsFaulted || LoadingAvatars[playerSteamId].IsCanceled)
				{
					PlayerAvatars.Add(playerSteamId, null);
				}
			}
		}

		public static Texture2D GetTextureFromImage(Image? image)
		{
			//IL_0012: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0030: 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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (image.HasValue)
			{
				Texture2D val = new Texture2D((int)image.Value.Width, (int)image.Value.Height);
				Color[] array = (Color[])(object)new Color[image.Value.Width * image.Value.Height];
				for (int i = 0; i < image.Value.Width; i++)
				{
					for (int j = 0; j < image.Value.Height; j++)
					{
						Image value = image.Value;
						Color pixel = ((Image)(ref value)).GetPixel(i, j);
						array[i + (image.Value.Height - (j + 1)) * image.Value.Width] = new Color((float)(int)pixel.r / 255f, (float)(int)pixel.g / 255f, (float)(int)pixel.b / 255f, (float)(int)pixel.a / 255f);
					}
				}
				val.SetPixels(array);
				val.Apply();
				return val;
			}
			return null;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		public static void UpdatePost(PlayerControllerB __instance)
		{
			LoadAvatar(__instance);
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)__instance)
			{
				VisionEnhancerEffect.Update();
				PietSmietController.UpdateEffect();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		[HarmonyPrefix]
		public static void DamagePlayer(PlayerControllerB __instance, ref int damageNumber, bool hasDamageSFX, bool callRPC, CauseOfDeath causeOfDeath, int deathAnimation, bool fallDamage, Vector3 force)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)__instance && !fallDamage && (int)causeOfDeath != 2)
				{
					damageNumber = (int)((float)damageNumber * Perks.GetMultiplier(__instance, "Damage"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchPlayerJump(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->PlayerJump...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].IsLdfld("GameNetcodeStuff.PlayerControllerB.jumpForce"))
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("JumpHeight", list, i + 1);
					Plugin.Log.LogDebug((object)"Added jump height to jump!");
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->PlayerJump...");
			return list.AsEnumerable();
		}

		private static IEnumerable<CodeInstruction> PatchJump_performed(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->Jump_performed...");
			MethodInfo method = typeof(AdvancedCompany.Game.Player).GetMethod("PerformJump", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 0.08f)
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("JumpStamina", list, i + 1);
					Plugin.Log.LogDebug((object)"Added jump stamina to jump!");
					flag = true;
				}
				if (flag && flag2)
				{
					break;
				}
			}
			list.Insert(0, new CodeInstruction(OpCodes.Call, (object)method));
			list.Insert(0, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->Jump_performed...");
			return list.AsEnumerable();
		}

		private static IEnumerable<CodeInstruction> PatchPlayerHitGroundEffects(ILGenerator generator, IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->PlayerHitGroundEffects...");
			bool flag = false;
			bool flag2 = false;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldc_R4 && list[i].operand is float num && true && (num == -9f || num == -16f || num == -2f || num == -48.5f || num == -45f || num == -40f))
				{
					Plugin.Log.LogDebug((object)("Added FallDamage Multiplier to " + num));
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("FallDamage", list, i + 1);
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->PlayerHitGroundEffects...");
			return list.AsEnumerable();
		}

		private static IEnumerable<CodeInstruction> PatchLateUpdate(ILGenerator generator, IEnumerable<CodeInstruction> instructions)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->LateUpdate...");
			bool flag = false;
			bool flag2 = false;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			LocalBuilder localBuilder = generator.DeclareLocal(typeof(float));
			list.Insert(0, new CodeInstruction(OpCodes.Stloc, (object)localBuilder));
			list.Insert(0, new CodeInstruction(OpCodes.Mul, (object)null));
			list.Insert(0, new CodeInstruction(OpCodes.Call, (object)AdvancedCompany.IL.Patches.GetMultiplier));
			list.Insert(0, new CodeInstruction(OpCodes.Ldstr, (object)"SprintStamina"));
			list.Insert(0, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerControllerB), "sprintTime")));
			list.Insert(0, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			for (int i = 6; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single sprintTime")
				{
					list.RemoveAt(i);
					list.RemoveAt(i - 1);
					list.Insert(i - 1, new CodeInstruction(OpCodes.Ldloc, (object)localBuilder));
					if (list[i + 1].opcode == OpCodes.Add)
					{
						Plugin.Log.LogDebug((object)"Adding sprint regen multiplier.");
						AdvancedCompany.IL.Patches.AddMultiplierInstruction("StaminaRegen", list, i + 3);
					}
				}
				if (!flag2 && list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single carryWeight")
				{
					AdvancedCompany.IL.Patches.AddWeightMultiplierInstruction("Weight", list, i + 1);
					Plugin.Log.LogDebug((object)"Added Weight multiplier.");
					flag2 = true;
				}
				if (flag && flag2)
				{
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->LateUpdate...");
			return list.AsEnumerable();
		}

		private static IEnumerable<CodeInstruction> PatchUpdate(IEnumerable<CodeInstruction> instructions)
		{
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Expected O, but got Unknown
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching PlayerControllerB->Update...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			bool flag5 = false;
			bool flag6 = false;
			MethodInfo method = typeof(AdvancedCompany.Game.Player).GetMethod("Movement", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			for (int i = 0; i < list.Count; i++)
			{
				if (!flag && list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == 2.25f)
				{
					list.RemoveAt(i + 2);
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("SprintSpeed", list, i + 2, addMul: false);
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("SprintSpeed", list, i + 1);
					flag = true;
					Plugin.Log.LogDebug((object)"Added SprintSpeed multiplier.");
				}
				if (!flag2 && list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Single climbSpeed")
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("ClimbingSpeed", list, i + 1);
					flag2 = true;
					Plugin.Log.LogDebug((object)"Added ClimbingSpeed multiplier.");
				}
				if (!flag3 && list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Boolean suckingPlayersOutOfShip")
				{
					object obj = null;
					for (int j = i; j < list.Count; j++)
					{
						if (list[j].opcode == OpCodes.Ldfld && list[j].operand.ToString() == "System.Boolean isClimbingLadder" && list[j + 1].opcode == OpCodes.Brfalse)
						{
							obj = list[j + 1].operand;
							break;
						}
					}
					list.Insert(i - 7, new CodeInstruction(OpCodes.Brtrue, obj));
					list.Insert(i - 7, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i - 7, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					flag3 = true;
				}
				if (!flag4 && list[i].opcode == OpCodes.Ldc_R4 && (float)list[i].operand == -35f)
				{
					Plugin.Log.LogDebug((object)("Added FallDamage multiplier to " + list[i].operand));
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("FallDamage", list, i + 1);
					flag4 = true;
				}
				if (!flag5 && list[i].IsLdfld("GameNetcodeStuff.PlayerControllerB.carryWeight"))
				{
					AdvancedCompany.IL.Patches.AddWeightMultiplierInstruction("WeightSpeed", list, i + 1);
					flag5 = true;
					Plugin.Log.LogDebug((object)"Added WeightSpeed multiplier.");
				}
				if (!flag6 && list[i].IsLdfld("GameNetcodeStuff.PlayerControllerB.jumpForce"))
				{
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("JumpHeight", list, i + 1);
					flag6 = true;
					Plugin.Log.LogDebug((object)"Added jump height to jump!");
				}
				if (flag && flag2 && flag3 && flag4 && flag5 && flag6)
				{
					break;
				}
			}
			MethodInfo method2 = typeof(AdvancedCompany.Game.Player).GetMethod("OnUpdate", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			list.Insert(0, new CodeInstruction(OpCodes.Call, (object)method2));
			list.Insert(0, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			Plugin.Log.LogDebug((object)"Patched PlayerControllerB->Update...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPatch(typeof(PlayerControllerB), "PlayerHitGroundEffects")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase method)
		{
			if (method.Name == "Jump_performed")
			{
				return PatchJump_performed(instructions);
			}
			if (method.Name == "LateUpdate")
			{
				return PatchLateUpdate(generator, instructions);
			}
			if (method.Name == "Update")
			{
				return PatchUpdate(instructions);
			}
			if (method.Name == "PlayerHitGroundEffects")
			{
				return PatchPlayerHitGroundEffects(generator, instructions);
			}
			return instructions;
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		[HarmonyPostfix]
		public static void Reequip(StartOfRound __instance)
		{
			for (int i = 0; i < __instance.allPlayerScripts.Length; i++)
			{
				if (__instance.allPlayerScripts[i].isPlayerControlled)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(__instance.allPlayerScripts[i]);
					player.Reequip();
				}
			}
		}
	}
	[HarmonyPatch]
	internal class RoundManager
	{
		private static Random Random;

		[HarmonyPatch(typeof(RoundManager), "Update")]
		[HarmonyPostfix]
		public static void Update(RoundManager __instance)
		{
			AdvancedCompany.Game.Player.Update();
		}

		public static void SetRandom()
		{
			Random = new Random(StartOfRound.Instance.randomMapSeed);
		}

		public static bool ShouldSaveObject()
		{
			return Random.NextDouble() < (double)Perks.GetMultiplier("SaveLoot");
		}

		[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchResetShip(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching RoundManager->DespawnPropsAtEndOfRound...");
			MethodInfo method = typeof(RoundManager).GetMethod("SetRandom", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			MethodInfo method2 = typeof(RoundManager).GetMethod("ShouldSaveObject", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString().Contains("isScrap"))
				{
					object operand = list[i + 1].operand;
					list.Insert(i + 2, new CodeInstruction(OpCodes.Brtrue, operand));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)method2));
					break;
				}
			}
			list.Insert(0, new CodeInstruction(OpCodes.Call, (object)method));
			Plugin.Log.LogDebug((object)"Patched RoundManager->DespawnPropsAtEndOfRound...");
			return list.AsEnumerable();
		}
	}
	internal class SavePatches
	{
		[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSaveItems(IEnumerable<CodeInstruction> instructions)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching GameNetworkManager->SaveItemsInShip...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo method = typeof(AdvancedCompany.Game.Manager.Save).GetMethod("SaveItemsInShip", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			if (list[3].opcode == OpCodes.Stloc_0 && list[4].opcode == OpCodes.Ldloc_0)
			{
				list.Insert(4, new CodeInstruction(OpCodes.Call, (object)method));
				list.Insert(4, new CodeInstruction(OpCodes.Ldloc_0, (object)null));
				Plugin.Log.LogDebug((object)"Added custom save method.");
			}
			else
			{
				Plugin.Log.LogWarning((object)"Couldn't find needed OpCodes for patching!");
			}
			Plugin.Log.LogDebug((object)"Patched GameNetworkManager->SaveItemsInShip!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(StartOfRound), "LoadShipGrabbableItems")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchLoadShipGrabbableItems(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->LoadShipGrabbableItems...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo method = typeof(AdvancedCompany.Game.Manager.Save).GetMethod("LoadItemsInShip", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			bool flag = true;
			for (int i = 0; i < list.Count; i++)
			{
				if (!(list[i].opcode == OpCodes.Ldstr) || !(list[i].operand.ToString() == "shipGrabbableItemIDs"))
				{
					continue;
				}
				if (flag)
				{
					flag = false;
					continue;
				}
				if (list[i + 4].opcode == OpCodes.Stloc_1)
				{
					Plugin.Log.LogDebug((object)"Found injection point for LoadItems");
					list.Insert(i + 5, new CodeInstruction(OpCodes.Stloc_1, (object)null));
					list.Insert(i + 5, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i + 5, new CodeInstruction(OpCodes.Ldloc_1, (object)null));
				}
				else
				{
					Plugin.Log.LogWarning((object)"Method was changed. Game update?");
				}
				break;
			}
			Plugin.Log.LogDebug((object)"Patched StartOfRound->LoadShipGrabbableItems!");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	internal class StartOfRound
	{
		private static float InitialShipAnimationSpeed = 1f;

		private static bool Initialized = false;

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPrefix]
		private static void Initialize(StartOfRound __instance)
		{
			PietSmietController.DoomRunning = false;
			Camera spectateCamera = __instance.spectateCamera;
			spectateCamera.cullingMask |= 0x800000;
			AdvancedCompany.Objects.VisionEnhancer.Initialize();
			__instance.voiceChatModule.OnPlayerStartedSpeaking += VoiceChatModule_OnPlayerStartedSpeaking;
			__instance.maxShipItemCapacity = 999;
			if (Initialized)
			{
				return;
			}
			InitialShipAnimationSpeed = __instance.shipAnimator.speed;
			Initialized = true;
			SelectableLevel[] array = (SelectableLevel[])AccessTools.Field(typeof(StartOfRound), "levels").GetValue(__instance);
			for (int i = 0; i < array.Length; i++)
			{
				for (int j = 0; j < array[i].spawnableScrap.Count; j++)
				{
					SpawnableItemWithRarity val = array[i].spawnableScrap[j];
					ExtractScrap(val.spawnableItem);
				}
			}
		}

		private static void VoiceChatModule_OnPlayerStartedSpeaking(VoicePlayerState obj)
		{
		}

		private static void ExtractAudio(AudioClip clip)
		{
			if (!((Object)(object)clip == (Object)null))
			{
				string name = ((Object)clip).name;
				if (!GameAssets.Audio.ContainsKey(name))
				{
					GameAssets.Audio.Add(name, clip);
				}
			}
		}

		private static void ExtractScrap(Item scrap)
		{
			if (!((Object)(object)scrap == (Object)null))
			{
				string itemName = scrap.itemName;
				if (!GameAssets.Scrap.ContainsKey(itemName))
				{
					GameAssets.Scrap.Add(itemName, scrap);
					ExtractAudio(scrap.dropSFX);
					ExtractAudio(scrap.pocketSFX);
					ExtractAudio(scrap.grabSFX);
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		[HarmonyPrefix]
		private static void Leaving(StartOfRound __instance)
		{
			if (Initialized)
			{
				__instance.shipAnimator.speed = InitialShipAnimationSpeed / Mathf.Max(0.15f, Perks.GetMultiplier("LandingSpeed"));
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "openingDoorsSequence")]
		[HarmonyPrefix]
		private static void Entering(StartOfRound __instance)
		{
			if (Initialized)
			{
				__instance.shipAnimator.speed = InitialShipAnimationSpeed / Mathf.Max(0.05f, Perks.GetMultiplier("LandingSpeed"));
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "EndOfGame")]
		[HarmonyPrefix]
		private static void ResetAnimatorSpeed(StartOfRound __instance)
		{
			if (Initialized)
			{
				__instance.shipAnimator.speed = InitialShipAnimationSpeed;
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
		[HarmonyPrefix]
		private static void ResetShip(StartOfRound __instance)
		{
			AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota = 0;
			AdvancedCompany.Network.Manager.Lobby.CurrentShip.ExtendedDeadline = false;
			if (!ServerConfiguration.Instance.General.SaveProgress && ServerConfiguration.Instance.General.ResetXP)
			{
				AdvancedCompany.Network.Manager.Lobby.Player().XP = ServerConfiguration.Instance.General.StartingXP;
				AdvancedCompany.Network.Manager.Lobby.Player().Levels = new Dictionary<string, int>();
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.XP = ServerConfiguration.Instance.General.StartingShipXP;
				AdvancedCompany.Network.Manager.Lobby.CurrentShip.Levels = new Dictionary<string, int>();
				if (NetworkManager.Singleton.IsServer)
				{
					AdvancedCompany.Network.Manager.Lobby.CurrentShip.ResetSave(GameNetworkManager.Instance.currentSaveFileName);
				}
			}
			if (NetworkManager.Singleton.IsServer)
			{
				AdvancedCompany.Network.Manager.Send(new ChangeShip
				{
					TotalQuota = 0,
					ExtendedDeadline = false
				}, 0uL);
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "FirePlayersAfterDeadlineClientRpc")]
		[HarmonyPostfix]
		public static void FirePlayersAfterDeadlineClientRpc(StartOfRound __instance)
		{
			TextMeshProUGUI endOfRunStatsText = HUDManager.Instance.EndOfRunStatsText;
			((TMP_Text)endOfRunStatsText).text = ((TMP_Text)endOfRunStatsText).text + "\nXP: " + AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota;
		}

		public static bool ShouldSaveObject(UnlockableItem item)
		{
			return item.unlockableType == 0 && ServerConfiguration.Instance.General.SaveSuitsAfterDeath;
		}

		[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchResetShip(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->ResetShip...");
			MethodInfo method = typeof(StartOfRound).GetMethod("ShouldSaveObject", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Boolean spawnPrefab" && list[i + 1].opcode == OpCodes.Brfalse)
				{
					object operand = list[i + 1].operand;
					list.Insert(i + 2, new CodeInstruction(OpCodes.Brtrue, operand));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i + 2, new CodeInstruction(list[i - 1].opcode, list[i - 1].operand));
					list.Insert(i + 2, new CodeInstruction(list[i - 2].opcode, list[i - 2].operand));
					list.Insert(i + 2, new CodeInstruction(list[i - 3].opcode, list[i - 3].operand));
					list.Insert(i + 2, new CodeInstruction(list[i - 4].opcode, list[i - 4].operand));
					list.Insert(i + 2, new CodeInstruction(list[i - 5].opcode, list[i - 5].operand));
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched StartOfRound->ResetShip...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchOpeningDoorsSequence(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StartOfRound->openingDoorsSequence...");
			PropertyInfo property = typeof(Perks).GetProperty("LandingSpeedMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldc_R4 && ((float)list[i].operand == 5f || (float)list[i].operand == 10f))
				{
					list.Insert(i + 1, new CodeInstruction(OpCodes.Mul, (object)null));
					AdvancedCompany.IL.Patches.AddMultiplierInstruction("LandingSpeed", list, i + 1, addMul: false);
				}
			}
			Plugin.Log.LogDebug((object)"Patched StartOfRound->openingDoorsSequence...");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch]
	internal class Terminal
	{
		[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchTextPostProcess(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching Terminal->TextPostProcess...");
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (!(list[i].opcode == OpCodes.Ldstr) || !(list[i].operand.ToString() == "[No items in stock!]"))
				{
					continue;
				}
				object obj = null;
				for (int j = i + 1; j < list.Count; j++)
				{
					if (list[j].opcode == OpCodes.Beq_S || list[j].opcode == OpCodes.Beq)
					{
						obj = list[j].operand;
						break;
					}
				}
				if (obj != null)
				{
					List<CodeInstruction> list2 = new List<CodeInstruction>();
					list2.Add(list[i + 12]);
					list2.Add(list[i + 13]);
					list2.Add(list[i + 14]);
					list2.Add(list[i + 15]);
					list2.Add(new CodeInstruction(OpCodes.Call, (object)typeof(AdvancedCompany.Game.Manager.Items).GetMethod("IsBuyable", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy)));
					list2.Add(new CodeInstruction(OpCodes.Brfalse, obj));
					list2.Add(new CodeInstruction(list[i + 9].opcode, list[i + 9].operand));
					List<CodeInstruction> list3 = list2;
					list[i + 9].opcode = list3[0].opcode;
					list[i + 9].operand = list3[0].operand;
					for (int num = list3.Count - 1; num >= 1; num--)
					{
						list.Insert(i + 10, list3[num]);
					}
					Plugin.Log.LogDebug((object)"Added activation check");
				}
				else
				{
					Plugin.Log.LogWarning((object)"Branch not found. Cant apply! Was the game updated?");
				}
				break;
			}
			Plugin.Log.LogDebug((object)"Patched Terminal->TextPostProcess!");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(Terminal), "LoadNewNodeIfAffordable")]
		[HarmonyPrefix]
		private static bool LoadNewNodeIfAffordable(Terminal __instance, TerminalNode node)
		{
			if (node.buyItemIndex >= 0 && __instance.buyableItemsList.Length > node.buyItemIndex)
			{
				Item val = __instance.buyableItemsList[node.buyItemIndex];
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(val.itemName);
				if (byItemName != null && !byItemName.Active)
				{
					__instance.LoadNewNode(__instance.terminalNodes.specialNodes[16]);
					return false;
				}
			}
			if (node.shipUnlockableID >= 0 && StartOfRound.Instance.unlockablesList.unlockables.Count > node.shipUnlockableID)
			{
				UnlockableItem val2 = StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID];
				LobbyConfiguration.UnlockableConfig byUnlockableName = ServerConfiguration.Instance.Items.GetByUnlockableName(val2.unlockableName);
				if (byUnlockableName != null && !byUnlockableName.Active)
				{
					__instance.LoadNewNode(__instance.terminalNodes.specialNodes[16]);
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal class TimeOfDay
	{
		public static float GetMultiplier()
		{
			return 700f / Mathf.Max(1f, (float)ServerConfiguration.Instance.General.DayLength);
		}

		[HarmonyPatch(typeof(TimeOfDay), "MoveGlobalTime")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TranspileStart(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching TimeOfDay->MoveGlobalTime...");
			MethodInfo method = typeof(TimeOfDay).GetMethod("GetMultiplier", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString().Contains("globalTimeSpeedMultiplier"))
				{
					list.Insert(i + 2, new CodeInstruction(OpCodes.Mul, (object)null));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)method));
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched TimeOfDay->MoveGlobalTime...");
			return list.AsEnumerable();
		}
	}
}
namespace AdvancedCompany.Objects
{
	internal abstract class Body : Clothing
	{
		public override int GetEquipmentSlot()
		{
			return 11;
		}
	}
	internal abstract class Boots : Clothing
	{
		public override int GetEquipmentSlot()
		{
			return 12;
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class BulletProofVest : Body, IIconProvider
	{
		public enum DamageOrigin
		{
			TURRET,
			SHOTGUN
		}

		public int Damage;

		private static GameObject VestPrefab;

		private static Sprite Damage0Icon;

		private static Sprite Damage1Icon;

		private static Sprite Damage2Icon;

		private static Texture2D Damage0Normal;

		private static Texture2D Damage1Normal;

		private static Texture2D Damage2Normal;

		private static float ProtectionChance0 = 0.99f;

		private static float ProtectionChance1 = 0.95f;

		private static float ProtectionChance2 = 0.9f;

		private Material Material;

		[HarmonyPatch(typeof(Turret), "Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> PatchTurretUpdate(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase methodBase)
		{
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching Turret->Update...");
			MethodInfo method = typeof(BulletProofVest).GetMethod("DamageVest", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Callvirt && list[i].operand.ToString() == "Void KillPlayer(UnityEngine.Vector3, Boolean, CauseOfDeath, Int32)")
				{
					list.RemoveAt(i - 15);
					list.RemoveAt(i - 15);
					list.RemoveAt(i - 15);
					list.Insert(i - 15, list[i - 7]);
					list.Insert(i - 15, list[i - 7]);
					list.Insert(i - 15, list[i - 7]);
					list.Insert(i - 15, list[i - 7]);
					list.Insert(i - 15, list[i - 7]);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.RemoveAt(i - 6);
					list.Insert(i - 6, list[i - 10]);
					list.Insert(i - 6, list[i - 11]);
					list.Insert(i - 6, list[i - 12]);
					list.Insert(i - 6, list[i - 13]);
					list.Insert(i - 6, list[i - 14]);
					list.Insert(i - 6, list[i - 15]);
					list.Insert(i - 6, list[i - 16]);
					list.Insert(i - 6, list[i - 17]);
					list.Insert(i - 6, list[i - 18]);
					list.Insert(i - 6, list[i - 19]);
					list.Insert(i - 6, list[i - 20]);
					list.Insert(i - 6, list[i - 21]);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				if (list[j].opcode == OpCodes.Callvirt && list[j].operand.ToString() == "Void DamagePlayer(Int32, Boolean, Boolean, CauseOfDeath, Int32, Boolean, UnityEngine.Vector3)")
				{
					list.Insert(j + 1, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(j + 1, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					list.Insert(j + 1, list[j - 12]);
					list.Insert(j + 1, list[j - 13]);
				}
			}
			Plugin.Log.LogDebug((object)"Patched Turret->Update...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(ShotgunItem), "ShootGun")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> PatchShootGun(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase methodBase)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching ShotgunItem->ShootGun...");
			MethodInfo method = typeof(BulletProofVest).GetMethod("DamageVest", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Callvirt && list[i].operand.ToString() == "Void DamagePlayer(Int32, Boolean, Boolean, CauseOfDeath, Int32, Boolean, UnityEngine.Vector3)")
				{
					list.Insert(i + 1, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i + 1, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
					list.Insert(i + 1, list[i - 12]);
				}
			}
			Plugin.Log.LogDebug((object)"Patched ShotgunItem->ShootGun...");
			return list.AsEnumerable();
		}

		public static void DamageVest(PlayerControllerB instance, DamageOrigin origin)
		{
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(instance);
			if ((Object)(object)player.Body != (Object)null && player.Body is BulletProofVest bulletProofVest)
			{
				switch (origin)
				{
				case DamageOrigin.TURRET:
					Plugin.Log.LogMessage((object)"Turret is damaging vest.");
					bulletProofVest.TakeDamage(ServerConfiguration.Instance.Items.BulletProofVest.TurretDamage);
					break;
				case DamageOrigin.SHOTGUN:
					Plugin.Log.LogMessage((object)"Shotgun is damaging vest.");
					bulletProofVest.TakeDamage(ServerConfiguration.Instance.Items.BulletProofVest.ShotgunDamage);
					break;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		[HarmonyPrefix]
		public static void DamagePlayer(PlayerControllerB __instance, ref int damageNumber, bool hasDamageSFX, bool callRPC, CauseOfDeath causeOfDeath, int deathAnimation, bool fallDamage, Vector3 force)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			if ((int)causeOfDeath != 7)
			{
				return;
			}
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(__instance);
			if (player.Body is BulletProofVest bulletProofVest)
			{
				float num = ((float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage - (float)bulletProofVest.Damage) / (float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage;
				float num2 = ServerConfiguration.Instance.Items.BulletProofVest.DamageReductionAtNoHealth + num * (ServerConfiguration.Instance.Items.BulletProofVest.DamageReductionAtFullHealth - ServerConfiguration.Instance.Items.BulletProofVest.DamageReductionAtNoHealth);
				if (num2 < 0f)
				{
					num2 = 0f;
				}
				if (num2 > 1f)
				{
					num2 = 1f;
				}
				damageNumber = (int)((float)damageNumber * (1f - num2));
			}
		}

		public void Awake()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			MeshRenderer component = ((Component)this).GetComponent<MeshRenderer>();
			Material = new Material(((Renderer)component).sharedMaterial);
			((Renderer)component).sharedMaterial = Material;
			SetNormal();
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			Transform[] bones = (Transform[])(object)new Transform[11]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.ROOT),
				player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_0),
				player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_1),
				player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_2),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_SHOULDER),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_LOWER_ARM),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_SHOULDER),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_LOWER_ARM),
				player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_3),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_THIGH),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_THIGH)
			};
			Transform bone = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			GameObject val = Object.Instantiate<GameObject>(VestPrefab, bone);
			val.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.ROOT);
			val.GetComponent<SkinnedMeshRenderer>().bones = bones;
			((Renderer)val.GetComponent<SkinnedMeshRenderer>()).ResetBounds();
			((Renderer)val.GetComponent<SkinnedMeshRenderer>()).sharedMaterial = Material;
			if (player.IsLocal)
			{
				val.layer = 23;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val2 in array)
				{
					((Component)val2).gameObject.layer = 23;
				}
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public override int GetItemDataToSave()
		{
			return Damage;
		}

		public override void LoadItemSaveData(int saveData)
		{
			Damage = saveData;
			SetNormal();
		}

		public void SetNormal()
		{
			if ((float)Damage < (float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage / 3f)
			{
				Material.SetTexture("_NormalMap", (Texture)(object)Damage0Normal);
			}
			else if ((float)Damage < (float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage * 2f / 3f)
			{
				Material.SetTexture("_NormalMap", (Texture)(object)Damage1Normal);
			}
			else
			{
				Material.SetTexture("_NormalMap", (Texture)(object)Damage2Normal);
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			VestPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/BulletProofVest.prefab");
			Damage0Icon = assets.LoadAsset<Sprite>("Assets/Icons/Items/BulletProofVest.png");
			Damage1Icon = assets.LoadAsset<Sprite>("Assets/Icons/Items/BulletProofVest1.png");
			Damage2Icon = assets.LoadAsset<Sprite>("Assets/Icons/Items/BulletProofVest2.png");
			Damage0Normal = assets.LoadAsset<Texture2D>("Assets/Models/BulletProofVest/BulletProofVestNormal.png");
			Damage1Normal = assets.LoadAsset<Texture2D>("Assets/Models/BulletProofVest/BulletProofVestDamage1Normal.png");
			Damage2Normal = assets.LoadAsset<Texture2D>("Assets/Models/BulletProofVest/BulletProofVestDamage2Normal.png");
		}

		public Sprite GetIcon()
		{
			if ((float)Damage < (float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage / 3f)
			{
				return Damage0Icon;
			}
			if ((float)Damage < (float)ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage * 2f / 3f)
			{
				return Damage1Icon;
			}
			return Damage2Icon;
		}

		public void TakeDamage(int amount)
		{
			Damage += amount;
			SetNormal();
			if (Damage >= ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage)
			{
				Damage = ServerConfiguration.Instance.Items.BulletProofVest.MaxDamage;
				if (ServerConfiguration.Instance.Items.BulletProofVest.DestroyAtNoHealth)
				{
					Destroy();
				}
			}
			GrabbableObjectAdditions.ChangeIcon((GrabbableObject)(object)this, GetIcon());
		}

		public void Destroy()
		{
			((Renderer)((Component)this).GetComponent<MeshRenderer>()).enabled = false;
			((Collider)((Component)this).GetComponent<BoxCollider>()).enabled = false;
			((GrabbableObject)this).grabbable = false;
			((GrabbableObject)this).grabbableToEnemies = false;
			((GrabbableObject)this).deactivated = true;
			Unequip();
			int inventoryPosition = GrabbableObjectAdditions.GetInventoryPosition((GrabbableObject)(object)this);
			if (inventoryPosition > -1)
			{
				PlayerControllerB playerHeldBy = ((GrabbableObject)this).playerHeldBy;
				playerHeldBy.carryWeight -= Mathf.Clamp(((GrabbableObject)this).itemProperties.weight - 1f, 0f, 10f);
				((GrabbableObject)this).playerHeldBy.ItemSlots[inventoryPosition] = null;
				if ((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					((Behaviour)HUDManager.Instance.itemSlotIcons[inventoryPosition]).enabled = false;
				}
			}
			((GrabbableObject)this).DiscardItemOnClient();
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	internal class BunnyEars : Helmet, ICursed, IOnUpdate, IMovement
	{
		private Light ItemLight;

		private Light ClothingLight;

		private float Phase = 0f;

		private Material ItemMaterial;

		private Material ClothingMaterial;

		private AudioSource ItemAudio;

		private AudioSource ClothingAudio;

		public bool CurseLifted = false;

		private bool CurseLiftedLastFrame = false;

		private float AttractEnemiesTimer = 0f;

		private PlayerControllerB lastPlayerHeldBy;

		internal static GameObject BunnyEarsPrefab;

		private bool LightsOn = true;

		private void Awake()
		{
			Phase = Random.value;
			ItemAudio = ((Component)((Component)this).transform.Find("Audio")).GetComponent<AudioSource>();
			ItemMaterial = ((Renderer)((Component)this).GetComponent<MeshRenderer>()).material;
			ItemLight = ((Component)this).GetComponentInChildren<Light>();
			if (!ClientConfiguration.Instance.Compability.DisableMusic)
			{
				ItemAudio.Play();
			}
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
		}

		private IEnumerator CurseEquip()
		{
			while (!CurseLifted && (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && !((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				if (((GrabbableObject)this).playerHeldBy.grabbedObjectValidated && !IsEquipped())
				{
					yield return (object)new WaitForEndOfFrame();
					yield return (object)new WaitForEndOfFrame();
					Equip();
					break;
				}
				yield return (object)new WaitForEndOfFrame();
			}
		}

		public override void GrabItem()
		{
			((GrabbableObject)this).GrabItem();
			if (!CurseLifted && !((GrabbableObject)this).playerHeldBy.isInHangarShipRoom && !IsEquipped())
			{
				((MonoBehaviour)this).StartCoroutine(CurseEquip());
			}
		}

		public override void Equipped(AdvancedCompany.Game.Player player)
		{
			base.Equipped(player);
			if (!CurseLifted && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				ItemAudio.Stop();
			}
		}

		public override void DiscardItem()
		{
			if (!CurseLifted && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				ItemAudio.Play();
			}
			((GrabbableObject)this).DiscardItem();
		}

		public override bool CanUnequip()
		{
			return CurseLifted;
		}

		private IEnumerator StopAudio()
		{
			if (!ClientConfiguration.Instance.Compability.DisableMusic)
			{
				ItemAudio.Stop();
				((Behaviour)ItemLight).enabled = false;
				float startVolume = ClothingAudio.volume;
				while ((Object)(object)ClothingAudio != (Object)null && ClothingAudio.pitch > 0f)
				{
					AudioSource clothingAudio = ClothingAudio;
					clothingAudio.pitch -= Time.deltaTime / 3f;
					ClothingAudio.volume = ClothingAudio.pitch * startVolume;
					yield return (object)new WaitForEndOfFrame();
				}
				ClothingAudio.Stop();
			}
			else
			{
				yield return (object)new WaitForEndOfFrame();
			}
		}

		public override void Update()
		{
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			bool flag = ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && ((GrabbableObject)this).isHeld && ((GrabbableObject)this).playerHeldBy.currentItemSlot == GrabbableObjectAdditions.GetInventoryPosition((GrabbableObject)(object)this)) || (Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null;
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && ((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				CurseLifted = true;
			}
			if (CurseLifted)
			{
				ItemMaterial.SetFloat("_EmissiveExposureWeight", 2f);
				if ((Object)(object)ClothingMaterial != (Object)null)
				{
					ClothingMaterial.SetFloat("_EmissiveExposureWeight", 2f);
				}
				((Behaviour)ItemLight).enabled = false;
				if ((Object)(object)ClothingLight != (Object)null)
				{
					((Behaviour)ClothingLight).enabled = false;
				}
				if (CurseLifted != CurseLiftedLastFrame)
				{
					((MonoBehaviour)this).StartCoroutine(StopAudio());
				}
				else if (ItemAudio.isPlaying)
				{
					ItemAudio.Stop();
				}
			}
			else
			{
				if ((Object)(object)ItemAudio != (Object)null)
				{
					ItemAudio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
				}
				if ((Object)(object)ClothingAudio != (Object)null)
				{
					ClothingAudio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
				}
				if (flag != LightsOn)
				{
					((Behaviour)ItemLight).enabled = flag;
					LightsOn = flag;
				}
				Phase += Time.deltaTime / 5f;
				while (Phase > 1f)
				{
					Phase -= 1f;
				}
				Color val = Color.HSVToRGB(Phase % 1f, 1f, 1f);
				ItemMaterial.SetColor("_EmissiveColor", val);
				ItemLight.color = val;
				if ((Object)(object)ClothingMaterial != (Object)null)
				{
					ClothingMaterial.SetColor("_EmissiveColor", val);
				}
				if ((Object)(object)ClothingLight != (Object)null)
				{
					ClothingLight.color = val;
				}
			}
			CurseLiftedLastFrame = CurseLifted;
			lastPlayerHeldBy = ((GrabbableObject)this).playerHeldBy;
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			Transform bone = player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_3);
			GameObject val = Object.Instantiate<GameObject>(BunnyEarsPrefab, bone);
			val.transform.localPosition = new Vector3(-0.002f, 0.389f, 0.079f);
			val.transform.localRotation = Quaternion.Euler(-91.477f, 0f, -179.998f);
			val.transform.localScale = new Vector3(0.4f, 0.4f, 0.4f);
			ClothingMaterial = ((Renderer)val.GetComponent<MeshRenderer>()).material;
			ClothingLight = val.GetComponentInChildren<Light>();
			ClothingAudio = val.GetComponent<AudioSource>();
			if (player.IsLocal)
			{
				val.layer = 23;
			}
			ItemAudio.Stop();
			if (!CurseLifted)
			{
				((Behaviour)ClothingLight).enabled = true;
				if (!ClientConfiguration.Instance.Compability.DisableMusic)
				{
					ClothingAudio.Play();
				}
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public static void LoadAssets(AssetBundle assets)
		{
			BunnyEarsPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/BunnyEars.prefab");
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
		[HarmonyPrefix]
		public static bool DiscardHeldObject(PlayerControllerB __instance)
		{
			if (__instance.currentlyHeldObjectServer is BunnyEars bunnyEars && !bunnyEars.CurseLifted)
			{
				return false;
			}
			return true;
		}

		public override int GetItemDataToSave()
		{
			return CurseLifted ? 1 : 0;
		}

		public override void LoadItemSaveData(int saveData)
		{
			((GrabbableObject)this).LoadItemSaveData(saveData);
			CurseLifted = saveData == 1;
			CurseLiftedLastFrame = CurseLifted;
		}

		public void OnUpdate(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				PlayerControllerB controller = player.Controller;
				controller.sprintMeter += Time.deltaTime * 0.2f;
			}
		}

		public void UpdateEffects(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				player.SetMultiplierOverride("WeightSpeed", 0f);
				player.SetMultiplierOverride("Weight", 0f);
				player.SetMultiplierOverride("SprintSpeed", 1f);
				player.SetMultiplierOverride("FallDamage", 10f);
				player.SetMultiplierOverride("JumpHeight", 0.7f);
				player.SetMultiplierOverride("SprintStamina", 100f);
				player.SetMultiplierOverride("JumpStamina", 100f);
			}
		}

		public bool Movement(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				player.IsPlayerSliding = false;
				player.IsMovementHindered = 0;
				if (!player.IsJumping && !player.IsFallingFromJump && !player.IsFallingNoJump)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal abstract class Clothing : GrabbableObject, IClothing
	{
		public static MethodInfo FirstEmptyItemSlotMethod = typeof(PlayerControllerB).GetMethod("FirstEmptyItemSlot", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);

		public virtual AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.NONE;
		}

		public virtual GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			return null;
		}

		public virtual bool CanUnequip()
		{
			return true;
		}

		public virtual void Equipped(AdvancedCompany.Game.Player player)
		{
		}

		public virtual void Equip()
		{
			if (!(base.playerHeldBy.ItemSlots[GetEquipmentSlot()] is IClothing clothing) || clothing.CanUnequip())
			{
				AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
				{
					PlayerNum = (int)base.playerHeldBy.playerClientId,
					FromSlot = base.playerHeldBy.currentItemSlot,
					ToSlot = GetEquipmentSlot()
				}, 0uL);
			}
		}

		public virtual void Unequipped(AdvancedCompany.Game.Player player)
		{
		}

		public virtual void Unequip()
		{
			if (!CanUnequip() || !((Object)(object)base.playerHeldBy != (Object)null))
			{
				return;
			}
			int num = Perks.InventorySlotsOf(base.playerHeldBy);
			int num2 = -1;
			for (int i = 0; i < num; i++)
			{
				if ((Object)(object)base.playerHeldBy.ItemSlots[i] == (Object)null)
				{
					num2 = i;
					break;
				}
			}
			if (num2 == -1)
			{
				((GrabbableObject)this).DiscardItem();
				return;
			}
			AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
			{
				PlayerNum = (int)base.playerHeldBy.playerClientId,
				FromSlot = base.playerHeldBy.currentItemSlot,
				ToSlot = num2
			}, 0uL);
		}

		public virtual int GetEquipmentSlot()
		{
			return -1;
		}

		public bool IsEquipped()
		{
			int equipmentSlot = GetEquipmentSlot();
			if (equipmentSlot == -1)
			{
				return false;
			}
			if ((Object)(object)base.playerHeldBy != (Object)null)
			{
				return (Object)(object)base.playerHeldBy.ItemSlots[equipmentSlot] == (Object)(object)this;
			}
			return false;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (IsEquipped())
			{
				Unequip();
			}
			else
			{
				Equip();
			}
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	internal class Flippers : Boots, IMovement
	{
		private static GameObject LeftSwimmingFin;

		private static GameObject RightSwimmingFin;

		private bool LastFrameActive = false;

		private float Gravity = 0f;

		private float MaxTarget = 6f;

		private bool PreviousSpecialAnimation;

		public override AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.HIDE_FEET;
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			Transform[] bones = (Transform[])(object)new Transform[4]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_FOOT),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_SHIN)
			};
			Transform[] bones2 = (Transform[])(object)new Transform[4]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_FOOT),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_SHIN)
			};
			Transform bone = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			GameObject val = Object.Instantiate<GameObject>(LeftSwimmingFin, bone);
			val.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.L_SHIN);
			val.GetComponent<SkinnedMeshRenderer>().bones = bones;
			GameObject val2 = Object.Instantiate<GameObject>(RightSwimmingFin, bone);
			val2.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.R_SHIN);
			val2.GetComponent<SkinnedMeshRenderer>().bones = bones2;
			if (player.IsLocal)
			{
				val.layer = 23;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val3 in array)
				{
					((Component)val3).gameObject.layer = 23;
				}
				val2.layer = 23;
				componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array2 = componentsInChildren;
				foreach (Transform val4 in array2)
				{
					((Component)val4).gameObject.layer = 23;
				}
			}
			return (GameObject[])(object)new GameObject[2] { val, val2 };
		}

		public static void LoadAssets(AssetBundle assets)
		{
			LeftSwimmingFin = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/FlippersLeft.prefab");
			RightSwimmingFin = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/FlippersRight.prefab");
		}

		public bool Movement(AdvancedCompany.Game.Player player)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(((Component)player.Controller.gameplayCamera).transform.position, 0.5f);
			bool flag = false;
			for (int i = 0; i < array.Length; i++)
			{
				QuicksandTrigger component = ((Component)array[i]).GetComponent<QuicksandTrigger>();
				if (!((Object)(object)component != (Object)null) || !component.isWater)
				{
					continue;
				}
				Bounds bounds = array[i].bounds;
				flag = ((Bounds)(ref bounds)).Contains(((Component)player.Controller.gameplayCamera).transform.position + new Vector3(0f, LastFrameActive ? (-0.5f) : 0f, 0f));
				if (flag)
				{
					if (player.IsUnderwater && (Object)(object)player.Controller.underwaterCollider != (Object)(object)array[i])
					{
						player.Controller.underwaterCollider = array[i];
					}
					break;
				}
			}
			if (flag)
			{
				if (!LastFrameActive)
				{
					Gravity = player.FallValue;
				}
				if (player.Controller.thisController.isGrounded)
				{
					Gravity = 0f;
				}
				Vector3 val = ((Component)player.Controller.gameplayCamera).transform.forward * player.Controller.moveInputVector.y + ((Component)player.Controller.gameplayCamera).transform.right * player.Controller.moveInputVector.x;
				MovementActions movement = player.Controller.playerActions.Movement;
				if (((MovementActions)(ref movement)).Jump.IsPressed())
				{
					val.y = 1.5f;
				}
				movement = player.Controller.playerActions.Movement;
				if (((MovementActions)(ref movement)).Crouch.IsPressed())
				{
					val.y = -1.5f;
				}
				if (((Vector3)(ref val)).magnitude > MaxTarget)
				{
					val = ((Vector3)(ref val)).normalized * MaxTarget;
				}
				player.WalkForce = Vector3.MoveTowards(player.WalkForce, val, 30f * Time.deltaTime);
				if (Gravity < -2f)
				{
					Gravity += Time.deltaTime * 40f;
					if (Gravity > -2f)
					{
						Gravity = -2f;
					}
				}
				if (Gravity > -2f)
				{
					Gravity -= Time.deltaTime * 40f;
					if (Gravity < -2f)
					{
						Gravity = -2f;
					}
				}
				player.SprintMultiplier = 2.25f;
				player.Controller.isSprinting = true;
				player.FallValue = player.WalkForce.y * 1.5f;
				player.FallValueUncapped = player.FallValue;
				player.IsMovementHindered = 0;
				player.MovementHinderedPrev = 0;
				float num = Mathf.Clamp(10f * ServerConfiguration.Instance.Items.Flippers.Speed - player.Controller.carryWeight * 5f * Perks.GetMultiplier(Perks.WeightSpeedPerk), 2f, 10f * ServerConfiguration.Instance.Items.Flippers.Speed);
				Vector3 val2 = player.WalkForce * num + new Vector3(0f, Gravity, 0f);
				player.Controller.thisController.Move(val2 * Time.deltaTime);
				LastFrameActive = true;
				return true;
			}
			if (LastFrameActive)
			{
				player.IsMovementHindered = 0;
				player.MovementHinderedPrev = 0;
				LastFrameActive = false;
				return false;
			}
			return false;
		}

		static Flippers()
		{
		}
	}
	internal class GrabbableObjectAdditions
	{
		public static Sprite GetIcon(GrabbableObject obj)
		{
			if (obj is IIconProvider iconProvider)
			{
				return iconProvider.GetIcon();
			}
			return obj.itemProperties.itemIcon;
		}

		public static int GetInventoryPosition(GrabbableObject obj)
		{
			if ((Object)(object)obj.playerHeldBy != (Object)null)
			{
				for (int i = 0; i < obj.playerHeldBy.ItemSlots.Length; i++)
				{
					if ((Object)(object)obj.playerHeldBy.ItemSlots[i] == (Object)(object)obj)
					{
						return i;
					}
				}
			}
			return -1;
		}

		public static void ChangeIcon(GrabbableObject obj, Sprite icon)
		{
			if ((Object)(object)obj.playerHeldBy != (Object)null && (Object)(object)obj.playerHeldBy == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				int inventoryPosition = GetInventoryPosition(obj);
				if (inventoryPosition > -1)
				{
					HUDManager.Instance.itemSlotIcons[inventoryPosition].sprite = icon;
				}
			}
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class Headset : WalkieTalkie, IEquipmentCommunication, IHelmet, IClothing
	{
		private static GameObject HeadsetPrefab;

		private float Phase = 0f;

		private bool Speaking = false;

		public virtual AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.NONE;
		}

		static Headset()
		{
		}

		public bool CanUnequip()
		{
			return true;
		}

		public override void Start()
		{
			base.thisAudio = ((Component)this).GetComponent<AudioSource>();
			base.target = ((Component)((Component)this).transform.Find("Target")).GetComponent<AudioSource>();
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (items.itemName == "Walkie-talkie")
				{
					WalkieTalkie component = items.spawnPrefab.GetComponent<WalkieTalkie>();
					base.talkingOnWalkieTalkieNotHeldSFX = component.talkingOnWalkieTalkieNotHeldSFX;
					base.switchWalkieTalkiePowerOn = component.switchWalkieTalkiePowerOn;
					base.switchWalkieTalkiePowerOff = component.switchWalkieTalkiePowerOff;
					base.stopTransmissionSFX = component.stopTransmissionSFX;
					base.startTransmissionSFX = component.startTransmissionSFX;
					base.recordingRange = component.recordingRange;
					base.playerDieOnWalkieTalkieSFX = component.playerDieOnWalkieTalkieSFX;
					break;
				}
			}
			((WalkieTalkie)this).Start();
		}

		public override void EquipItem()
		{
			if (((NetworkBehaviour)this).IsOwner)
			{
				HUDManager.Instance.ClearControlTips();
				((GrabbableObject)this).SetControlTipsForItem();
			}
			((GrabbableObject)this).EnableItemMeshes(true);
			((GrabbableObject)this).isPocketed = false;
			if (!((GrabbableObject)this).hasBeenHeld)
			{
				((GrabbableObject)this).hasBeenHeld = true;
				if (!((GrabbableObject)this).isInShipRoom && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.currentLevel.spawnEnemiesAndScrap)
				{
					RoundManager instance = RoundManager.Instance;
					instance.valueOfFoundScrapItems += ((GrabbableObject)this).scrapValue;
				}
			}
		}

		public override void PocketItem()
		{
			if (((NetworkBehaviour)this).IsOwner && (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
			{
				((GrabbableObject)this).playerHeldBy.IsInspectingItem = false;
			}
			((GrabbableObject)this).isPocketed = true;
			((GrabbableObject)this).EnableItemMeshes(false);
			((Component)this).gameObject.GetComponent<AudioSource>().PlayOneShot(((GrabbableObject)this).itemProperties.pocketSFX, 1f);
		}

		public static void Initialize()
		{
		}

		public override void Update()
		{
			((WalkieTalkie)this).Update();
			if (!((GrabbableObject)this).isBeingUsed)
			{
			}
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
			((GrabbableObject)this).isBeingUsed = false;
			((WalkieTalkie)this).DiscardItem();
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (IsEquipped())
			{
				Unequip();
			}
			else
			{
				Equip();
			}
		}

		public GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(HeadsetPrefab, player.HeadMount.transform);
			val.transform.localPosition = new Vector3(0f, -0.15f, 0.1433f);
			val.transform.localRotation = Quaternion.Euler(0.053f, 0f, 0f);
			if (player.IsLocal)
			{
				val.layer = 23;
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public override void UseUpBatteries()
		{
			((WalkieTalkie)this).UseUpBatteries();
			((GrabbableObject)this).isBeingUsed = false;
			base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOff);
			if (((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie)
			{
				((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			HeadsetPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/Headset.prefab");
		}

		public bool CanBeUsed()
		{
			if (((GrabbableObject)this).insertedBattery != null && ((GrabbableObject)this).insertedBattery.charge > 0f)
			{
				return true;
			}
			return false;
		}

		public void SwitchTalking(AdvancedCompany.Game.Player player, bool talking)
		{
			Speaking = talking;
			if (talking)
			{
				((MonoBehaviour)this).StartCoroutine(Speak());
			}
		}

		private IEnumerator Speak()
		{
			base.speakingIntoWalkieTalkie = true;
			base.previousPlayerHeldBy.activatingItem = true;
			((WalkieTalkie)this).SetLocalClientSpeaking(true);
			yield return (object)new WaitForSeconds(0.2f);
			yield return (object)new WaitUntil((Func<bool>)(() => !Speaking || !((GrabbableObject)this).isBeingUsed));
			((WalkieTalkie)this).SetLocalClientSpeaking(false);
			base.speakingIntoWalkieTalkie = false;
			base.previousPlayerHeldBy.activatingItem = false;
		}

		public virtual void Equipped(AdvancedCompany.Game.Player player)
		{
			((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = true;
			((GrabbableObject)this).playerHeldBy = player.Controller;
			base.previousPlayerHeldBy = player.Controller;
			base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOn);
			((GrabbableObject)this).isBeingUsed = true;
		}

		public void Equip()
		{
			AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				FromSlot = ((GrabbableObject)this).playerHeldBy.currentItemSlot,
				ToSlot = GetEquipmentSlot()
			}, 0uL);
		}

		public void Unequipped(AdvancedCompany.Game.Player player)
		{
			try
			{
				base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOff);
				((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
				if (base.speakingIntoWalkieTalkie)
				{
					((WalkieTalkie)this).SetLocalClientSpeaking(false);
				}
				((GrabbableObject)this).isBeingUsed = false;
			}
			catch (Exception)
			{
			}
		}

		public void Unequip()
		{
			if (!((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null))
			{
				return;
			}
			int num = Perks.InventorySlotsOf(((GrabbableObject)this).playerHeldBy);
			int num2 = -1;
			for (int i = 0; i < num; i++)
			{
				if ((Object)(object)((GrabbableObject)this).playerHeldBy.ItemSlots[i] == (Object)null)
				{
					num2 = i;
					break;
				}
			}
			if (num2 == -1)
			{
				((GrabbableObject)this).DiscardItem();
				return;
			}
			AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				FromSlot = ((GrabbableObject)this).playerHeldBy.currentItemSlot,
				ToSlot = num2
			}, 0uL);
		}

		public int GetEquipmentSlot()
		{
			return 10;
		}

		public bool IsEquipped()
		{
			int equipmentSlot = GetEquipmentSlot();
			if (equipmentSlot == -1)
			{
				return false;
			}
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
			{
				return (Object)(object)((GrabbableObject)this).playerHeldBy.ItemSlots[equipmentSlot] == (Object)(object)this;
			}
			return false;
		}
	}
	internal abstract class Helmet : Clothing, IHelmet, IClothing
	{
		public override int GetEquipmentSlot()
		{
			return 10;
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class HelmetLamp : Helmet, IEquipmentFlashlight
	{
		private static GameObject HelmetLampPrefab;

		private Material Material;

		private Light Light1;

		private Light Light2;

		private Light Light3;

		private float StrengthTarget = 1f;

		private float Strength = 1f;

		private float StrengthTime = 0.5f;

		private float StrengthPhase = 1f;

		private float Phase = 0f;

		static HelmetLamp()
		{
			AdvancedCompany.Network.Manager.AddListener(delegate(ActivateHelmetLamp msg)
			{
				if (msg.PlayerNum != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(msg.PlayerNum);
					if (player.Helmet is HelmetLamp helmetLamp)
					{
						helmetLamp.SwitchFlashlight(player, msg.IsUsed);
					}
				}
			});
		}

		public override void Start()
		{
			((GrabbableObject)this).Start();
		}

		public static void Initialize()
		{
		}

		public bool IsUsed()
		{
			return ((GrabbableObject)this).isBeingUsed;
		}

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if (((GrabbableObject)this).isBeingUsed)
			{
				if ((Object)(object)Light2 != (Object)null && !((Behaviour)Light2).enabled)
				{
					((Behaviour)Light2).enabled = true;
				}
				Phase = Mathf.Clamp01(Phase + Time.deltaTime * 5f);
				if (StrengthPhase >= 1f)
				{
					StrengthTime = Random.Range(0.1f, 0.3f);
					StrengthTarget = Random.Range(0.95f, 1.12f);
					Strength = StrengthTarget;
					StrengthPhase = 0f;
				}
				else
				{
					float num = Strength + (StrengthTarget - Strength) * StrengthPhase;
					StrengthPhase += Time.deltaTime / StrengthTime;
					if ((Object)(object)Light2 != (Object)null)
					{
						Light2.intensity = 100f * Phase * num;
					}
				}
			}
			else
			{
				if ((Object)(object)Light2 != (Object)null && ((Behaviour)Light2).enabled)
				{
					((Behaviour)Light2).enabled = false;
				}
				Phase = Mathf.Clamp01(Phase - Time.deltaTime * 5f);
			}
			if ((Object)(object)Material != (Object)null)
			{
				Material.SetFloat("_EmissiveExposureWeight", 2f - Phase * 2f);
			}
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			base.ItemActivate(used, buttonDown);
			((GrabbableObject)this).isBeingUsed = false;
		}

		public override void Unequipped(AdvancedCompany.Game.Player player)
		{
			((GrabbableObject)this).isBeingUsed = false;
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(HelmetLampPrefab, player.HeadMount.transform);
			val.transform.localPosition = new Vector3(-0.0015f, 0.066f, 0.008f);
			val.transform.localRotation = Quaternion.Euler(-0.053f, 180f, 0f);
			Light[] componentsInChildren = val.GetComponentsInChildren<Light>();
			Light2 = componentsInChildren[0];
			Renderer component = val.GetComponent<Renderer>();
			Material = component.material;
			if (player.IsLocal)
			{
				((Component)component).gameObject.layer = 23;
				((Component)Light2).transform.parent = ((Component)player.Controller.gameplayCamera).transform;
				((Component)Light2).transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
				((Component)Light2).transform.localPosition = new Vector3(0f, 0.5f, 0.45f);
				return (GameObject[])(object)new GameObject[2]
				{
					val,
					((Component)Light2).gameObject
				};
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public override void UseUpBatteries()
		{
			((GrabbableObject)this).UseUpBatteries();
			((GrabbableObject)this).isBeingUsed = false;
			AdvancedCompany.Network.Manager.Send(new ActivateHelmetLamp
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				IsUsed = false
			}, 0uL);
		}

		public static void LoadAssets(AssetBundle assets)
		{
			HelmetLampPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/HelmetLamp.prefab");
		}

		public void SwitchFlashlight(AdvancedCompany.Game.Player player, bool on)
		{
			if (!on || !(((GrabbableObject)this).insertedBattery.charge <= 0f))
			{
				if (player.IsLocal)
				{
					AdvancedCompany.Network.Manager.Send(new ActivateHelmetLamp
					{
						PlayerNum = player.PlayerNum,
						IsUsed = on
					}, 0uL);
				}
				((GrabbableObject)this).isBeingUsed = on;
			}
		}

		public bool CanBeUsed()
		{
			if (((GrabbableObject)this).insertedBattery != null && ((GrabbableObject)this).insertedBattery.charge > 0f)
			{
				return true;
			}
			return false;
		}
	}
	internal interface IClothing
	{
		bool CanUnequip();

		AdvancedCompany.Game.Player.BodyLayers GetLayers();

		GameObject[] CreateWearable(AdvancedCompany.Game.Player player);

		void Equipped(AdvancedCompany.Game.Player player);

		void Equip();

		void Unequipped(AdvancedCompany.Game.Player player);

		void Unequip();

		int GetEquipmentSlot();

		bool IsEquipped();
	}
	public interface ICursed
	{
		internal void UpdateEffects(AdvancedCompany.Game.Player player);
	}
	internal interface IEquipmentCommunication
	{
		void SwitchTalking(AdvancedCompany.Game.Player player, bool talking);
	}
	internal interface IEquipmentFlashlight
	{
		bool IsUsed();

		void SwitchFlashlight(AdvancedCompany.Game.Player player, bool on);

		bool CanBeUsed();
	}
	internal interface IHelmet : IClothing
	{
	}
	[HarmonyPatch]
	internal class LightningRod : GrabbableObject
	{
		private static List<LightningRod> AllLightningRods = new List<LightningRod>();

		private Animator Animator;

		public bool Extend = false;

		private bool _Extended = false;

		public AudioSource Rod0Sound;

		public AudioSource Rod1Sound;

		public AudioSource Rod2Sound;

		public AudioSource Rod3Sound;

		public AudioSource Rod4Sound;

		public AudioSource RodHeadSound;

		public Transform RodPoint;

		public static Vector3 CatchLightning(Vector3 position)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < AllLightningRods.Count; i++)
			{
				if ((Object)(object)AllLightningRods[i] == (Object)null)
				{
					AllLightningRods.RemoveAt(i);
					i--;
				}
				else if (((Component)AllLightningRods[i].RodPoint).transform.position.y > position.y)
				{
					return ((Component)AllLightningRods[i].RodPoint).transform.position;
				}
			}
			return position;
		}

		public static bool IsTargetable(GrabbableObject thing)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < AllLightningRods.Count; i++)
			{
				if ((Object)(object)AllLightningRods[i] == (Object)null)
				{
					AllLightningRods.RemoveAt(i);
					i--;
				}
				else if (((Component)AllLightningRods[i].RodPoint).transform.position.y > ((Component)thing).transform.position.y)
				{
					return false;
				}
			}
			return true;
		}

		public void Awake()
		{
			Animator = ((Component)this).GetComponent<Animator>();
			Transform val = ((Component)this).transform.Find("Rod0");
			Rod0Sound = ((Component)val.Find("Sound")).GetComponent<AudioSource>();
			Transform val2 = val.Find("Rod1");
			Rod1Sound = ((Component)val2.Find("Sound")).GetComponent<AudioSource>();
			Transform val3 = val2.Find("Rod2");
			Rod2Sound = ((Component)val3.Find("Sound")).GetComponent<AudioSource>();
			Transform val4 = val3.Find("Rod3");
			Rod3Sound = ((Component)val4.Find("Sound")).GetComponent<AudioSource>();
			Transform val5 = val4.Find("Rod4");
			Rod4Sound = ((Component)val5.Find("Sound")).GetComponent<AudioSource>();
			Transform val6 = val5.Find("RodHead");
			RodHeadSound = ((Component)val6.Find("Sound")).GetComponent<AudioSource>();
			RodPoint = val6.Find("Point");
		}

		public override void Update()
		{
			((GrabbableObject)this).Update();
			if (Extend && !_Extended)
			{
				_Extended = true;
				Animator.SetBool("Expand", true);
			}
			if (!Extend && _Extended)
			{
				_Extended = false;
				Animator.SetBool("Expand", false);
			}
		}

		public override void OnDestroy()
		{
			((NetworkBehaviour)this).OnDestroy();
			AllLightningRods.Remove(this);
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Lightning Rod used");
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if ((Object)(object)base.playerHeldBy != (Object)null && !base.playerHeldBy.isInHangarShipRoom && !base.playerHeldBy.isInsideFactory)
			{
				if (((NetworkBehaviour)this).IsOwner)
				{
					base.playerHeldBy.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
				}
				((MonoBehaviour)this).StartCoroutine(PlayExtend());
			}
		}

		public override void GrabItem()
		{
			((GrabbableObject)this).GrabItem();
			Extend = false;
		}

		private IEnumerator PlayExtend()
		{
			yield return (object)new WaitForSeconds(2f);
			if ((Object)(object)base.playerHeldBy == (Object)null)
			{
				AllLightningRods.Add(this);
				base.grabbable = false;
				((Component)this).gameObject.layer = 0;
				Extend = true;
			}
		}

		public void PlaySoundRod0()
		{
			Rod0Sound.Play();
		}

		public void PlaySoundRod1()
		{
			Rod1Sound.Play();
		}

		public void PlaySoundRod2()
		{
			Rod2Sound.Play();
		}

		public void PlaySoundRod3()
		{
			Rod3Sound.Play();
		}

		public void PlaySoundRod4()
		{
			Rod4Sound.Play();
		}

		public void PlaySoundRodHead()
		{
			RodHeadSound.Play();
		}

		[HarmonyPatch(typeof(StormyWeather), "LightningStrikeRandom")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchLightningStrikeRandom(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StormyWeather->LightningStrikeRandom...");
			MethodInfo method = typeof(LightningRod).GetMethod("CatchLightning", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int num = list.Count - 1; num >= 0; num--)
			{
				if (list[num].opcode == OpCodes.Ldloc_0)
				{
					list.Insert(num + 1, new CodeInstruction(OpCodes.Call, (object)method));
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched StormyWeather->LightningStrikeRandom...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(StormyWeather), "Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchUpdate(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching StormyWeather->Update...");
			MethodInfo method = typeof(LightningRod).GetMethod("IsTargetable", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString() == "System.Boolean isInFactory")
				{
					list.Insert(i + 2, new CodeInstruction(OpCodes.Brfalse, list[i + 1].operand));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i + 2, new CodeInstruction(list[i - 1].opcode, list[i - 1].operand));
					list.Insert(i + 2, new CodeInstruction(list[i - 2].opcode, list[i - 2].operand));
					if (num == 1)
					{
						list.Insert(i + 2, new CodeInstruction(list[i - 3].opcode, list[i - 3].operand));
						list.Insert(i + 2, new CodeInstruction(list[i - 4].opcode, list[i - 4].operand));
					}
					num++;
				}
			}
			Plugin.Log.LogDebug((object)"Patched StormyWeather->Update...");
			return list.AsEnumerable();
		}

		public override void DiscardItem()
		{
			if (!base.isPocketed && (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability))
			{
				AdvancedCompany.Game.Player.GetPlayer(base.playerHeldBy)?.RemoveOverride("HoldOneHandedItem", syncOverride: true);
			}
			((GrabbableObject)this).DiscardItem();
		}

		public override void EquipItem()
		{
			if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				AdvancedCompany.Game.Player.GetPlayer(base.playerHeldBy)?.AddOverride("HoldOneHandedItem", "HoldLightningRod", syncOverride: true);
			}
			((GrabbableObject)this).EquipItem();
		}
	}
	public class LightShoeRGB : MonoBehaviour
	{
		private Light[] Lights;

		private float[] Hues;

		private float Phase;

		internal AudioSource Audio;

		internal Material Material;

		private ParticleSystem ParticleSystem;

		private bool CurseIsLifted = false;

		private void Awake()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Phase = Random.value;
			Audio = ((Component)this).GetComponentInChildren<AudioSource>();
			ParticleSystem = ((Component)this).GetComponentInChildren<ParticleSystem>();
			Lights = ((Component)this).GetComponentsInChildren<Light>();
			Hues = new float[Lights.Length];
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			for (int i = 0; i < Lights.Length; i++)
			{
				Color.RGBToHSV(Lights[i].color, ref num, ref num2, ref num3);
				Hues[i] = num;
			}
		}

		public void CurseLifted()
		{
			if (!CurseIsLifted)
			{
				CurseIsLifted = true;
				ParticleSystem.Stop();
				((MonoBehaviour)this).StartCoroutine(LiftCurse());
			}
		}

		private IEnumerator LiftCurse()
		{
			for (int i = 0; i < Lights.Length; i++)
			{
				((Behaviour)Lights[i]).enabled = false;
			}
			float startVolume = Audio.volume;
			while (Audio.pitch > 0f)
			{
				AudioSource audio = Audio;
				audio.pitch -= Time.deltaTime / 3f;
				Audio.volume = Audio.pitch * startVolume;
				yield return (object)new WaitForEndOfFrame();
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public void Play()
		{
			if ((Object)(object)Audio != (Object)null && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				Audio.Play();
			}
			if ((Object)(object)ParticleSystem != (Object)null)
			{
				ParticleSystem.Play();
			}
		}

		public void Stop()
		{
			if ((Object)(object)Audio != (Object)null && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				Audio.Stop();
			}
			if ((Object)(object)ParticleSystem != (Object)null)
			{
				ParticleSystem.Stop();
			}
		}

		private void Update()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			Phase += Time.deltaTime;
			while (Phase > 1f)
			{
				Phase -= 1f;
			}
			Material.SetTextureOffset("_EmissiveColorMap", new Vector2(0f, Phase));
			for (int i = 0; i < Lights.Length; i++)
			{
				Lights[i].color = Color.HSVToRGB((Hues[i] + Phase) % 1f, 1f, 1f);
			}
		}
	}
	[HarmonyPatch]
	[LoadAssets]
	internal class LightShoes : Boots, ICursed, IOnUpdate
	{
		private static GameObject LeftLightShoe;

		private static GameObject RightLightShoe;

		private static GameObject LeftRGB;

		private static GameObject RightRGB;

		private Light[] Lights;

		private float[] Hues;

		private float Phase = 0f;

		private Material Material;

		private AudioSource Audio;

		private bool LightsOn = true;

		private GameObject LeftRGBInstance;

		private GameObject RightRGBInstance;

		public bool CurseLifted = false;

		private float AttractEnemiesTimer = 0f;

		private PlayerControllerB lastPlayerHeldBy;

		private void Awake()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			Phase = Random.value;
			Audio = ((Component)((Component)this).transform.Find("Audio")).GetComponent<AudioSource>();
			Material = ((Renderer)((Component)this).GetComponent<MeshRenderer>()).materials[1];
			Lights = ((Component)this).GetComponentsInChildren<Light>();
			Hues = new float[Lights.Length];
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			for (int i = 0; i < Lights.Length; i++)
			{
				Color.RGBToHSV(Lights[i].color, ref num, ref num2, ref num3);
				Hues[i] = num;
			}
			if (!ClientConfiguration.Instance.Compability.DisableMusic)
			{
				Audio.Play();
			}
		}

		public override void EquipItem()
		{
			((GrabbableObject)this).EquipItem();
		}

		private IEnumerator CurseEquip()
		{
			while (!CurseLifted && (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && !((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				if (((GrabbableObject)this).playerHeldBy.grabbedObjectValidated && !IsEquipped())
				{
					yield return (object)new WaitForEndOfFrame();
					yield return (object)new WaitForEndOfFrame();
					Equip();
					break;
				}
				yield return (object)new WaitForEndOfFrame();
			}
		}

		public override void GrabItem()
		{
			((GrabbableObject)this).GrabItem();
			if (!CurseLifted && !((GrabbableObject)this).playerHeldBy.isInHangarShipRoom && !IsEquipped())
			{
				((MonoBehaviour)this).StartCoroutine(CurseEquip());
			}
		}

		public override void Equipped(AdvancedCompany.Game.Player player)
		{
			base.Equipped(player);
			if (!CurseLifted && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				Audio.Stop();
			}
		}

		public override void DiscardItem()
		{
			if (!CurseLifted && !ClientConfiguration.Instance.Compability.DisableMusic)
			{
				Audio.Play();
			}
			((GrabbableObject)this).DiscardItem();
		}

		public override bool CanUnequip()
		{
			return CurseLifted;
		}

		public override void Update()
		{
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			bool flag = ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && ((GrabbableObject)this).isHeld && ((GrabbableObject)this).playerHeldBy.currentItemSlot == GrabbableObjectAdditions.GetInventoryPosition((GrabbableObject)(object)this)) || (Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null;
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && ((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				CurseLifted = true;
			}
			if (NetworkManager.Singleton.IsServer && (CurseLifted || ((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null && (Object)(object)lastPlayerHeldBy != (Object)(object)((GrabbableObject)this).playerHeldBy)))
			{
				foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
				{
					if (((NetworkBehaviour)spawnedEnemy).IsOwner && (Object)(object)spawnedEnemy.targetPlayer == (Object)(object)lastPlayerHeldBy)
					{
						spawnedEnemy.targetPlayer = null;
						spawnedEnemy.movingTowardsTargetPlayer = false;
					}
				}
			}
			if (CurseLifted)
			{
				Material.SetFloat("_EmissiveExposureWeight", 2f);
				for (int i = 0; i < Lights.Length; i++)
				{
					((Behaviour)Lights[i]).enabled = false;
				}
				if (Audio.isPlaying)
				{
					Audio.Stop();
				}
				if ((Object)(object)LeftRGBInstance != (Object)null)
				{
					LeftRGBInstance.GetComponent<LightShoeRGB>().CurseLifted();
				}
				if ((Object)(object)RightRGBInstance != (Object)null)
				{
					RightRGBInstance.GetComponent<LightShoeRGB>().CurseLifted();
				}
			}
			else
			{
				if ((Object)(object)Audio != (Object)null)
				{
					Audio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
				}
				if ((Object)(object)LeftRGBInstance != (Object)null)
				{
					LightShoeRGB component = LeftRGBInstance.GetComponent<LightShoeRGB>();
					if ((Object)(object)component != (Object)null && (Object)(object)component.Audio != (Object)null)
					{
						component.Audio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
					}
				}
				if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
				{
					foreach (EnemyAI spawnedEnemy2 in RoundManager.Instance.SpawnedEnemies)
					{
						if (spawnedEnemy2.isOutside == !((GrabbableObject)this).playerHeldBy.isInsideFactory && ((NetworkBehaviour)spawnedEnemy2).IsOwner)
						{
							spawnedEnemy2.StopSearch(spawnedEnemy2.currentSearch, true);
							spawnedEnemy2.movingTowardsTargetPlayer = true;
							spawnedEnemy2.targetPlayer = ((GrabbableObject)this).playerHeldBy;
						}
					}
				}
				if (flag != LightsOn)
				{
					for (int j = 0; j < Lights.Length; j++)
					{
						((Behaviour)Lights[j]).enabled = flag;
					}
					LightsOn = flag;
				}
				if (LightsOn)
				{
					Phase += Time.deltaTime / 5f;
					while (Phase > 1f)
					{
						Phase -= 1f;
					}
					Material.SetTextureOffset("_EmissiveColorMap", new Vector2(0f, Phase));
					for (int k = 0; k < Lights.Length; k++)
					{
						Lights[k].color = Color.HSVToRGB((Hues[k] + Phase) % 1f, 1f, 1f);
					}
				}
			}
			lastPlayerHeldBy = ((GrabbableObject)this).playerHeldBy;
		}

		public override AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.HIDE_FEET;
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			Transform[] bones = (Transform[])(object)new Transform[3]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_FOOT)
			};
			Transform[] bones2 = (Transform[])(object)new Transform[3]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_FOOT)
			};
			Transform bone = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			GameObject val = Object.Instantiate<GameObject>(LeftLightShoe, bone);
			val.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.L_SHIN);
			val.GetComponent<SkinnedMeshRenderer>().bones = bones;
			GameObject val2 = Object.Instantiate<GameObject>(RightLightShoe, bone);
			val2.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.R_SHIN);
			val2.GetComponent<SkinnedMeshRenderer>().bones = bones2;
			if (player.IsLocal)
			{
				val.layer = 23;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val3 in array)
				{
					((Component)val3).gameObject.layer = 23;
				}
				val2.layer = 23;
				componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array2 = componentsInChildren;
				foreach (Transform val4 in array2)
				{
					((Component)val4).gameObject.layer = 23;
				}
			}
			if (!CurseLifted)
			{
				LeftRGBInstance = Object.Instantiate<GameObject>(LeftRGB, player.GetBone(AdvancedCompany.Game.Player.Bone.L_FOOT));
				LeftRGBInstance.transform.localScale = Vector3.zero;
				LeftRGBInstance.transform.localPosition = Vector3.zero;
				LightShoeRGB lightShoeRGB = LeftRGBInstance.AddComponent<LightShoeRGB>();
				lightShoeRGB.Material = ((Renderer)val.GetComponent<SkinnedMeshRenderer>()).materials[1];
				RightRGBInstance = Object.Instantiate<GameObject>(RightRGB, player.GetBone(AdvancedCompany.Game.Player.Bone.R_FOOT));
				RightRGBInstance.transform.localScale = Vector3.zero;
				RightRGBInstance.transform.localPosition = Vector3.zero;
				LightShoeRGB lightShoeRGB2 = RightRGBInstance.AddComponent<LightShoeRGB>();
				lightShoeRGB2.Material = ((Renderer)val2.GetComponent<SkinnedMeshRenderer>()).materials[1];
				lightShoeRGB.Play();
				lightShoeRGB2.Play();
				if (player.IsLocal)
				{
					LeftRGBInstance.layer = 23;
					RightRGBInstance.layer = 23;
				}
				return (GameObject[])(object)new GameObject[4] { val, val2, LeftRGBInstance, RightRGBInstance };
			}
			return (GameObject[])(object)new GameObject[2] { val, val2 };
		}

		public static void LoadAssets(AssetBundle assets)
		{
			LeftLightShoe = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/LightShoeLeft.prefab");
			RightLightShoe = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/LightShoeRight.prefab");
			LeftRGB = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/RGBLeft.prefab");
			RightRGB = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/RGBRight.prefab");
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
		[HarmonyPrefix]
		public static bool DiscardHeldObject(PlayerControllerB __instance)
		{
			if (__instance.currentlyHeldObjectServer is LightShoes lightShoes && !lightShoes.CurseLifted)
			{
				return false;
			}
			return true;
		}

		public override int GetItemDataToSave()
		{
			return CurseLifted ? 1 : 0;
		}

		public override void LoadItemSaveData(int saveData)
		{
			((GrabbableObject)this).LoadItemSaveData(saveData);
			CurseLifted = saveData == 1;
		}

		public void OnUpdate(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				PlayerControllerB controller = player.Controller;
				controller.sprintMeter += Time.deltaTime * 2f;
			}
		}

		public void UpdateEffects(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				player.SetMultiplierOverride("WeightSpeed", 0f);
				player.SetMultiplierOverride("Weight", 0f);
				player.SetMultiplierOverride("SprintSpeed", 2f);
				player.SetMultiplierOverride("FallDamage", 10f);
				player.SetMultiplierOverride("JumpHeight", 1.5f);
				player.SetMultiplierOverride("SprintStamina", 100f);
			}
		}
	}
	[LoadAssets]
	internal class Loader
	{
		public static void LoadAssets(AssetBundle assets)
		{
			Plugin.Log.LogInfo((object)"Adding items...");
			try
			{
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/LightningRod.prefab").AddComponent<LightningRod>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/RocketBoots.prefab").AddComponent<RocketBoots>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/MissileLauncher.prefab").AddComponent<MissileLauncher>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/Flippers.prefab").AddComponent<Flippers>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/VisionEnhancer.prefab").AddComponent<VisionEnhancer>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/BulletproofVest.prefab").AddComponent<BulletProofVest>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/HelmetLamp.prefab").AddComponent<HelmetLamp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/Headset.prefab").AddComponent<Headset>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Items/TacticalHelmet.prefab").AddComponent<TacticalHelmet>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/LightShoes.prefab").AddComponent<LightShoes>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/BunnyEars.prefab").AddComponent<BunnyEars>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/Potatoes.prefab").AddComponent<PhysicsProp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/ToyCar.prefab").AddComponent<PhysicsProp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/ToyTank.prefab").AddComponent<PhysicsProp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/WarplaneToy.prefab").AddComponent<PhysicsProp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/Skillet.prefab").AddComponent<PhysicsProp>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/PietSmietController.prefab").AddComponent<PietSmietController>());
				AdvancedCompany.Game.Manager.AddItem((GrabbableObject)(object)assets.LoadAsset<GameObject>("Assets/Prefabs/Scrap/QuestionMarkBlock.prefab").AddComponent<PhysicsProp>());
				Plugin.Log.LogInfo((object)"Items added...");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while adding items!");
				Plugin.Log.LogError((object)ex);
			}
		}
	}
	internal class MissileLauncher : GrabbableObject
	{
		public int Ammo = 3;

		public Transform Rocket1;

		public Transform Rocket2;

		public Transform Rocket3;

		private void OnEnable()
		{
			Rocket1 = ((Component)this).transform.Find("Rocket1");
			Rocket2 = ((Component)this).transform.Find("Rocket2");
			Rocket3 = ((Component)this).transform.Find("Rocket3");
			UpdateAmmo();
		}

		public void UpdateAmmo()
		{
			((Component)Rocket1).gameObject.SetActive(Ammo > 0);
			((Component)Rocket2).gameObject.SetActive(Ammo > 1);
			((Component)Rocket3).gameObject.SetActive(Ammo > 2);
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (Ammo > 0)
			{
				Ammo--;
				UpdateAmmo();
				if ((Object)(object)base.playerHeldBy == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					Rocket.Spawn(Rocket1.position, Rocket1.rotation);
				}
			}
		}

		public override void LoadItemSaveData(int saveData)
		{
			Ammo = saveData;
			UpdateAmmo();
		}

		public override int GetItemDataToSave()
		{
			return Ammo;
		}

		public override void PocketItem()
		{
			if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				AdvancedCompany.Game.Player.GetPlayer(base.playerHeldBy)?.RemoveOverride("HoldOneHandedItem", syncOverride: true);
			}
			((GrabbableObject)this).PocketItem();
		}

		public override void DiscardItem()
		{
			if (!base.isPocketed && (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability))
			{
				AdvancedCompany.Game.Player.GetPlayer(base.playerHeldBy)?.RemoveOverride("HoldOneHandedItem", syncOverride: true);
			}
			((GrabbableObject)this).DiscardItem();
		}

		public override void EquipItem()
		{
			if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				AdvancedCompany.Game.Player.GetPlayer(base.playerHeldBy)?.AddOverride("HoldOneHandedItem", "HoldRocketLauncher", syncOverride: true);
			}
			((GrabbableObject)this).EquipItem();
		}
	}
	[Bootable]
	[HarmonyPatch]
	[LoadAssets]
	internal class PietSmietController : PhysicsProp, ICursed, IOnUpdate, IMovement
	{
		private float Phase = 0f;

		public bool CurseLifted = false;

		private bool CurseLiftedLastFrame = false;

		private PlayerControllerB lastPlayerHeldBy;

		private static GameObject DoomHUDPrefab;

		private DoomHUD DoomHUD;

		private Light Light;

		private AudioSource ActiveAudio;

		private AudioSource InactiveAudio;

		private static DoomEffect Instance;

		private static HDRP.PostProcessInstance PostProcessingInstance;

		internal static bool DoomRunning = false;

		private static List<EnemyAI> OutsideSpawnedEnemies = new List<EnemyAI>();

		private static List<EnemyAI> InsideSpawnedEnemies = new List<EnemyAI>();

		private static int CurrentInsideSpawnPos = 0;

		private static int CurrentOutsideSpawnPos = 0;

		private static List<EnemyType> SpawnInsideRotation = null;

		private static List<EnemyType> SpawnOutsideRotation = null;

		private static float SpawnTimer = 0f;

		private float WalkPhase = 0f;

		private float DamagePhase = 0f;

		private float ManiacPhase = 0f;

		private float LeftPhase = 0f;

		private float RightPhase = 0f;

		internal int Health = 100;

		internal int Armor = 100;

		public static void UpdateEffect()
		{
			((VolumeParameter<float>)(object)Instance.intensity).value = (DoomRunning ? 1f : 0f);
		}

		public static void Boot()
		{
			PostProcessingInstance = HDRP.AddPostProcessing<DoomEffect>(HDRP.InjectionPoint.AFTER_POSTPROCESS);
			Instance = (DoomEffect)(object)PostProcessingInstance.CurrentInstance;
			HDRP.PostProcessInstance postProcessingInstance = PostProcessingInstance;
			postProcessingInstance.OnInstanceChanged = (HDRP.PostProcessInstance.InstanceChanged)Delegate.Combine(postProcessingInstance.OnInstanceChanged, (HDRP.PostProcessInstance.InstanceChanged)delegate(VolumeComponent old, VolumeComponent instance)
			{
				if ((Object)(object)old != (Object)null && old is DoomEffect doomEffect)
				{
					((VolumeParameter<float>)(object)doomEffect.intensity).value = 0f;
				}
				Instance = (DoomEffect)(object)instance;
				((VolumeParameter<float>)(object)Instance.intensity).value = (DoomRunning ? 1f : 0f);
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(DoomShotgun msg)
			{
				//IL_0002: 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_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: 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)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: 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_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				Vector3 shotgunPosition = msg.ShotgunPosition;
				Vector3 shotgunForward = msg.ShotgunForward;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if ((int)localPlayerController.playerClientId != msg.PlayerNum)
				{
					Vector3 val = localPlayerController.playerCollider.ClosestPoint(msg.ShotgunPosition);
					bool flag = false;
					if (!Physics.Linecast(shotgunPosition, val, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1) && Vector3.Angle(shotgunForward, val - shotgunPosition) < 30f)
					{
						flag = Vector3.Distance(val, shotgunPosition) < 10f;
					}
					if (flag)
					{
						Vector3 val2 = ((Component)localPlayerController).transform.position - msg.ShotgunPosition;
						localPlayerController.KillPlayer(((Vector3)(ref val2)).normalized * 5f, true, (CauseOfDeath)7, 0);
					}
				}
				float num = 20f;
				if (NetworkManager.Singleton.IsServer)
				{
					Collider[] array = Physics.OverlapBox(msg.ShotgunPosition + msg.ShotgunForward * (num / 2f), new Vector3(1.5f, 4f, num / 2f), Quaternion.LookRotation(msg.ShotgunForward), -1, (QueryTriggerInteraction)2);
					Collider[] array2 = array;
					foreach (Collider val3 in array2)
					{
						Vector3 val4 = val3.ClosestPoint(msg.ShotgunPosition);
						if (!Physics.Linecast(shotgunPosition, val4, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							EnemyAI val5 = ((Component)val3).GetComponent<EnemyAI>();
							if ((Object)(object)val5 == (Object)null)
							{
								val5 = ((Component)val3).GetComponentInParent<EnemyAI>();
							}
							if ((Object)(object)val5 != (Object)null && !val5.isEnemyDead)
							{
								KillEnemy(val5);
							}
						}
					}
				}
			});
		}

		private static bool KillEnemy(EnemyAI enemy)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (enemy is SandWormAI)
			{
				return false;
			}
			if (enemy is BaboonBirdAI || enemy is MaskedPlayerEnemy || enemy is NutcrackerEnemyAI || enemy is SandSpiderAI || enemy is CentipedeAI || enemy is CrawlerAI || enemy is FlowermanAI || enemy is HoarderBugAI || enemy is MouthDogAI)
			{
				((NetworkBehaviour)enemy).__rpc_exec_stage = (__RpcExecStage)1;
				enemy.KillEnemyClientRpc(false);
			}
			else
			{
				enemy.CancelSpecialAnimationWithPlayer();
				if (!OutsideSpawnedEnemies.Contains(enemy) && !InsideSpawnedEnemies.Contains(enemy))
				{
					enemy.SubtractFromPowerLevel();
				}
				enemy.KillEnemy(true);
			}
			return true;
		}

		private void Awake()
		{
			InactiveAudio = ((Component)((Component)this).transform.Find("InactiveAudio")).GetComponent<AudioSource>();
			ActiveAudio = ((Component)((Component)this).transform.Find("ActiveAudio")).GetComponent<AudioSource>();
			if (!ClientConfiguration.Instance.Compability.DisableMusic)
			{
				InactiveAudio.Play();
			}
		}

		public override void EquipItem()
		{
			((PhysicsProp)this).EquipItem();
		}

		public override void GrabItem()
		{
			((GrabbableObject)this).GrabItem();
			if (!CurseLifted && !((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				StartDoom();
			}
		}

		internal void StartDoom()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (DoomRunning)
			{
				return;
			}
			DoomRunning = true;
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(((GrabbableObject)this).playerHeldBy);
			player.LockInventory = true;
			HUDManager.Instance.ToggleHUD(false);
			((Component)player.Controller.localArmsTransform.parent.parent).gameObject.SetActive(false);
			((GrabbableObject)this).EnableItemMeshes(false);
			if ((Object)(object)DoomHUD == (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(DoomHUDPrefab, ((Component)HUDManager.Instance.HUDAnimator).gameObject.transform.parent);
				val.GetComponent<RectTransform>().anchoredPosition = Vector2.zero;
				DoomHUD = val.GetComponent<DoomHUD>();
				if ((Object)(object)Instance != (Object)null)
				{
					((VolumeParameter<float>)(object)Instance.intensity).value = 1f;
				}
			}
			GameObject val2 = new GameObject("DoomLight");
			val2.transform.parent = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			val2.transform.localPosition = new Vector3(0f, 0f, 1f);
			val2.transform.localRotation = Quaternion.Euler(90f, 90f, 0f);
			Light = val2.AddComponent<Light>();
			Light.color = new Color(0.5f, 0.5f, 0.5f);
			Light.type = (LightType)0;
			Light.shape = (LightShape)2;
			Light.cullingMask = 2147483519;
			HDAdditionalLightData val3 = val2.AddComponent<HDAdditionalLightData>();
			val3.SetBoxSpotSize(new Vector2(500f, 500f));
			val3.SetIntensity(30f, (LightUnit)2);
			val3.spotLightShape = (SpotLightShape)2;
			val3.affectsVolumetric = true;
			val3.volumetricDimmer = 0f;
			val3.range = 1000f;
			val3.lightDimmer = 1f;
			val3.SetCullingMask(2147483519);
		}

		internal void StopDoom()
		{
			if (DoomRunning)
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(lastPlayerHeldBy);
				if ((Object)(object)Light != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)Light).gameObject);
					Light = null;
				}
				if ((Object)(object)DoomHUD != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)DoomHUD).gameObject);
					DoomHUD = null;
				}
				player.LockInventory = false;
				HUDManager.Instance.ToggleHUD(true);
				((Component)player.Controller.localArmsTransform.parent.parent).gameObject.SetActive(true);
				((GrabbableObject)this).EnableItemMeshes(true);
				if ((Object)(object)Instance != (Object)null)
				{
					((VolumeParameter<float>)(object)Instance.intensity).value = 0f;
				}
				DoomRunning = false;
			}
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).DiscardItem();
			StopDoom();
		}

		private IEnumerator StopAudio()
		{
			if (!ClientConfiguration.Instance.Compability.DisableMusic)
			{
				InactiveAudio.Stop();
				float startVolume = ActiveAudio.volume;
				while ((Object)(object)ActiveAudio != (Object)null && ActiveAudio.pitch > 0f)
				{
					AudioSource activeAudio = ActiveAudio;
					activeAudio.pitch -= Time.deltaTime / 3f;
					ActiveAudio.volume = ActiveAudio.pitch * startVolume;
					yield return (object)new WaitForEndOfFrame();
				}
				ActiveAudio.Stop();
			}
			else
			{
				yield return (object)new WaitForEndOfFrame();
			}
		}

		public override void Update()
		{
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_083a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Unknown result type (might be due to invalid IL or missing references)
			//IL_0861: Unknown result type (might be due to invalid IL or missing references)
			//IL_0866: Unknown result type (might be due to invalid IL or missing references)
			//IL_075b: Unknown result type (might be due to invalid IL or missing references)
			//IL_075d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			bool flag = (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null;
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && ((GrabbableObject)this).playerHeldBy.isInHangarShipRoom)
			{
				CurseLifted = true;
			}
			if ((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null && (Object)(object)lastPlayerHeldBy != (Object)null && (Object)(object)lastPlayerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				StopDoom();
			}
			if (CurseLifted)
			{
				if (!CurseLiftedLastFrame)
				{
					((MonoBehaviour)this).StartCoroutine(StopAudio());
					if (NetworkManager.Singleton.IsServer)
					{
						foreach (EnemyAI insideSpawnedEnemy in InsideSpawnedEnemies)
						{
							KillEnemy(insideSpawnedEnemy);
						}
						foreach (EnemyAI outsideSpawnedEnemy in OutsideSpawnedEnemies)
						{
							KillEnemy(outsideSpawnedEnemy);
						}
					}
					if ((Object)(object)lastPlayerHeldBy == (Object)(object)StartOfRound.Instance.localPlayerController)
					{
						StopDoom();
					}
				}
			}
			else
			{
				if ((Object)(object)InactiveAudio != (Object)null)
				{
					InactiveAudio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
				}
				if ((Object)(object)ActiveAudio != (Object)null)
				{
					ActiveAudio.volume = ClientConfiguration.Instance.Graphics.MusicVolume;
				}
				if (flag)
				{
					if (InactiveAudio.isPlaying)
					{
						InactiveAudio.Stop();
					}
					if (!ActiveAudio.isPlaying)
					{
						ActiveAudio.Play();
					}
				}
				else
				{
					if (!InactiveAudio.isPlaying)
					{
						InactiveAudio.Play();
					}
					if (ActiveAudio.isPlaying)
					{
						ActiveAudio.Stop();
					}
				}
				if (NetworkManager.Singleton.IsServer && (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
				{
					if (SpawnInsideRotation == null)
					{
						SpawnInsideRotation = new List<EnemyType>
						{
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Hoarding bug"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Bunker Spider"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Hoarding bug"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Bunker Spider"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Hoarding bug"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Bunker Spider"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Hoarding bug"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Crawler"].EnemyType
						};
						SpawnOutsideRotation = new List<EnemyType>
						{
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Baboon hawk"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Baboon hawk"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Baboon hawk"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["Baboon hawk"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType,
							AdvancedCompany.Game.Manager.Enemies.EnemiesByName["MouthDog"].EnemyType
						};
					}
					SpawnTimer -= Time.deltaTime;
					if (SpawnTimer <= 0f)
					{
						for (int i = 0; i < InsideSpawnedEnemies.Count; i++)
						{
							if ((Object)(object)InsideSpawnedEnemies[i] == (Object)null || InsideSpawnedEnemies[i].isEnemyDead)
							{
								InsideSpawnedEnemies.RemoveAt(i);
								i--;
							}
						}
						for (int j = 0; j < OutsideSpawnedEnemies.Count; j++)
						{
							if ((Object)(object)OutsideSpawnedEnemies[j] == (Object)null || OutsideSpawnedEnemies[j].isEnemyDead)
							{
								OutsideSpawnedEnemies.RemoveAt(j);
								j--;
							}
						}
						if (OutsideSpawnedEnemies.Count < 15)
						{
							GameObject[] array = GameObject.FindGameObjectsWithTag("OutsideAINode");
							Vector3 position = array[RoundManager.Instance.AnomalyRandom.Next(0, array.Length)].transform.position;
							position = RoundManager.Instance.GetRandomNavMeshPositionInRadius(position, 4f, default(NavMeshHit));
							int num = 0;
							bool flag2 = false;
							for (int k = 0; k < array.Length - 1; k++)
							{
								for (int l = 0; l < RoundManager.Instance.spawnDenialPoints.Length; l++)
								{
									flag2 = true;
									if (Vector3.Distance(position, RoundManager.Instance.spawnDenialPoints[l].transform.position) < 16f)
									{
										num = (num + 1) % array.Length;
										position = array[num].transform.position;
										position = RoundManager.Instance.GetRandomNavMeshPositionInRadius(position, 4f, default(NavMeshHit));
										flag2 = false;
										break;
									}
								}
								if (flag2)
								{
									break;
								}
							}
							GameObject val = Object.Instantiate<GameObject>(SpawnOutsideRotation[CurrentOutsideSpawnPos].enemyPrefab, position, Quaternion.Euler(Vector3.zero));
							val.gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
							EnemyAI val2 = val.GetComponent<EnemyAI>();
							if ((Object)(object)val2 == (Object)null)
							{
								val2 = val.GetComponentInChildren<EnemyAI>();
							}
							RoundManager.Instance.SpawnedEnemies.Add(val2);
							OutsideSpawnedEnemies.Add(val2);
							CurrentOutsideSpawnPos++;
							if (CurrentOutsideSpawnPos >= SpawnOutsideRotation.Count)
							{
								CurrentOutsideSpawnPos = 0;
							}
						}
						if (InsideSpawnedEnemies.Count < 15)
						{
							EnemyVent val3 = RoundManager.Instance.allEnemyVents[RoundManager.Instance.AnomalyRandom.Next(0, RoundManager.Instance.allEnemyVents.Length)];
							Vector3 position2 = val3.floorNode.position;
							GameObject val4 = Object.Instantiate<GameObject>(SpawnInsideRotation[CurrentInsideSpawnPos].enemyPrefab, position2, Quaternion.Euler(new Vector3(0f, 0f, 0f)));
							val4.GetComponentInChildren<NetworkObject>().Spawn(true);
							InsideSpawnedEnemies.Add(val4.GetComponent<EnemyAI>());
							RoundManager.Instance.SpawnedEnemies.Add(val4.GetComponent<EnemyAI>());
							CurrentInsideSpawnPos++;
							if (CurrentInsideSpawnPos >= SpawnInsideRotation.Count)
							{
								CurrentInsideSpawnPos = 0;
							}
						}
						SpawnTimer = 5f;
					}
				}
				if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
				{
					foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
					{
						if (spawnedEnemy.isOutside == !((GrabbableObject)this).playerHeldBy.isInsideFactory && ((NetworkBehaviour)spawnedEnemy).IsOwner)
						{
							spawnedEnemy.StopSearch(spawnedEnemy.currentSearch, true);
							spawnedEnemy.movingTowardsTargetPlayer = true;
							spawnedEnemy.targetPlayer = ((GrabbableObject)this).playerHeldBy;
						}
					}
				}
			}
			CurseLiftedLastFrame = CurseLifted;
			lastPlayerHeldBy = ((GrabbableObject)this).playerHeldBy;
		}

		public static void LoadAssets(AssetBundle assets)
		{
			DoomHUDPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/UI/DoomHUD.prefab");
		}

		[HarmonyPatch(typeof(ForestGiantAI), "IVisibleThreat.GetThreatVelocity")]
		[HarmonyPrefix]
		public static bool ForestGiantGetThreatVelocity(ForestGiantAI __instance)
		{
			if ((Object)(object)((EnemyAI)__instance).agent == (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MouthDogAI), "IVisibleThreat.GetThreatVelocity")]
		[HarmonyPrefix]
		public static bool MouthDogGetThreatVelocity(MouthDogAI __instance)
		{
			if ((Object)(object)((EnemyAI)__instance).agent == (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(ForestGiantAI), "GrabPlayerServerRpc")]
		[HarmonyPrefix]
		public static bool GrabPlayerServerRpc(ForestGiantAI __instance, int playerId)
		{
			if ((int)StartOfRound.Instance.localPlayerController.playerClientId == playerId && StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				pietSmietController.Damage(15);
				if (pietSmietController.Health <= 0)
				{
					return true;
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MouthDogAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		public static bool OnCollideWithPlayer(MouthDogAI __instance, Collider other)
		{
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, __instance.inKillAnimation, false);
			if ((Object)(object)val != (Object)null && ((EnemyAI)__instance).currentBehaviourStateIndex == 3 && val.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				if ((Object)(object)val == (Object)(object)StartOfRound.Instance.localPlayerController)
				{
					pietSmietController.Damage(15);
					if (pietSmietController.Health <= 0)
					{
						return true;
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(InteractTrigger), "CancelLadderAnimation")]
		[HarmonyPostfix]
		public static void CancelLadderAnimation(InteractTrigger __instance)
		{
			if ((Object)(object)__instance.playerScriptInSpecialAnimation.currentlyHeldObjectServer != (Object)null && __instance.playerScriptInSpecialAnimation.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				((GrabbableObject)pietSmietController).EnableItemMeshes(false);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "BeginGrabObject")]
		[HarmonyPrefix]
		public static bool BeginGrabObject(PlayerControllerB __instance)
		{
			if ((Object)(object)__instance.currentlyHeldObjectServer != (Object)null && __instance.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				return false;
			}
			return true;
		}

		internal void Damage(int damage)
		{
			if (DamagePhase > 0f)
			{
				return;
			}
			DoomHUD.HeadPhase = DoomHUD.SpritePhase.DAMAGE;
			DamagePhase = 0.7f;
			LeftPhase = 0f;
			RightPhase = 0f;
			ManiacPhase = 0f;
			if (Armor > 0)
			{
				Armor -= damage;
				if (Armor < 0)
				{
					damage = -Armor;
					Armor = 0;
				}
				else
				{
					damage = 0;
				}
			}
			if (damage > 0 && Health > 0)
			{
				Health -= damage;
				if (Health < 0)
				{
					Health = 0;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Crouch")]
		[HarmonyPrefix]
		public static bool Crouch(PlayerControllerB __instance, bool crouch)
		{
			if (__instance.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted && (Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController && crouch)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		[HarmonyPrefix]
		public static bool DamagePlayer(PlayerControllerB __instance)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
				{
					pietSmietController.Damage(5);
					if (pietSmietController.Health <= 0)
					{
						__instance.health = 0;
						__instance.KillPlayer(Vector3.zero, true, (CauseOfDeath)0, 0);
						return false;
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
		[HarmonyPrefix]
		public static bool DiscardHeldObject(PlayerControllerB __instance)
		{
			if (__instance.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "CalculateNormalLookingInput")]
		[HarmonyPostfix]
		public static void CalculateNormalLookingInput(PlayerControllerB __instance, ref Vector2 inputVector)
		{
			if (__instance.currentlyHeldObjectServer is PietSmietController)
			{
				__instance.cameraUp = Mathf.Clamp(__instance.cameraUp, -20f, 20f);
			}
		}

		public override int GetItemDataToSave()
		{
			return CurseLifted ? 1 : 0;
		}

		public override void LoadItemSaveData(int saveData)
		{
			((GrabbableObject)this).LoadItemSaveData(saveData);
			CurseLifted = saveData == 1;
			CurseLiftedLastFrame = CurseLifted;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).ItemActivate(used, buttonDown);
			if (!CurseLifted && DoomRunning && DoomHUD.Shoot())
			{
				AdvancedCompany.Network.Manager.Send(new DoomShotgun
				{
					PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
					ShotgunPosition = ((Component)((GrabbableObject)this).playerHeldBy.gameplayCamera).transform.position,
					ShotgunForward = ((Component)((GrabbableObject)this).playerHeldBy.gameplayCamera).transform.forward
				}, 0uL);
				if (Random.value > 0.5f)
				{
					DoomHUD.HeadPhase = DoomHUD.SpritePhase.MANIAC;
					ManiacPhase = 0.5f;
					LeftPhase = 0f;
					RightPhase = 0f;
					DamagePhase = 0f;
				}
			}
		}

		public void OnUpdate(AdvancedCompany.Game.Player player)
		{
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			if (!CurseLifted && DoomRunning)
			{
				player.Controller.health = 100;
				player.Controller.sprintMeter = 1f;
				DoomHUD.HP = Health;
				DoomHUD.Armor = Armor;
				if (DamagePhase > 0f)
				{
					DamagePhase -= Time.deltaTime;
				}
				if (ManiacPhase > 0f)
				{
					ManiacPhase -= Time.deltaTime;
				}
				if (LeftPhase > 0f)
				{
					LeftPhase -= Time.deltaTime;
					if (LeftPhase <= 0f)
					{
						RightPhase = 0.5f;
						DoomHUD.HeadPhase = DoomHUD.SpritePhase.RIGHT;
					}
				}
				if (RightPhase > 0f)
				{
					RightPhase -= Time.deltaTime;
				}
				if (ManiacPhase <= 0f && LeftPhase <= 0f && RightPhase <= 0f && DamagePhase <= 0f)
				{
					if (DoomHUD.HeadPhase != DoomHUD.SpritePhase.STRAIGHT)
					{
						DoomHUD.HeadPhase = DoomHUD.SpritePhase.STRAIGHT;
					}
					if (WalkPhase > 0f && Random.value > 0.998f)
					{
						LeftPhase = 0.5f;
						DoomHUD.HeadPhase = DoomHUD.SpritePhase.LEFT;
					}
				}
				if (((Vector2)(ref player.Controller.moveInputVector)).sqrMagnitude > 0.1f)
				{
					DoomHUD.ShotgunAnimator.SetBool("Walking", true);
					WalkPhase += Time.deltaTime * 5f;
					while (WalkPhase > MathF.PI)
					{
						WalkPhase -= MathF.PI;
					}
				}
				else
				{
					WalkPhase = Mathf.Lerp(WalkPhase, (WalkPhase > MathF.PI / 2f) ? MathF.PI : 0f, Time.deltaTime * 5f);
					DoomHUD.ShotgunAnimator.SetBool("Walking", false);
				}
				if (player.Controller.isCrouching)
				{
					player.Controller.Crouch(false);
				}
				((Component)player.Controller.gameplayCamera).transform.localPosition = new Vector3(0f, Mathf.Sin(WalkPhase) * -0.4f, 0f);
			}
			else
			{
				((Component)player.Controller.gameplayCamera).transform.localPosition = new Vector3(0f, 0f, 0f);
			}
		}

		public void UpdateEffects(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
				player.SetMultiplierOverride("WeightSpeed", 0f);
				player.SetMultiplierOverride("Weight", 0f);
				player.SetMultiplierOverride("SprintSpeed", 1f);
				player.SetMultiplierOverride("FallDamage", 10f);
				player.SetMultiplierOverride("JumpHeight", 1f);
				player.SetMultiplierOverride("SprintStamina", 100f);
				player.SetMultiplierOverride("JumpStamina", 100f);
			}
		}

		public bool Movement(AdvancedCompany.Game.Player player)
		{
			if (!CurseLifted)
			{
			}
			return false;
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class Rocket : MonoBehaviour
	{
		public static GameObject RocketAsset;

		public long ID;

		public long TempID;

		private List<(Vector3, Quaternion)> RocketPath;

		private ParticleSystem Smoke;

		private ParticleSystem Fireworks;

		private AudioSource Audio;

		private AudioSource FireworkAudio;

		private HDAdditionalLightData FireworkLightData;

		private Light FireworkLight;

		private GameObject Model;

		private float FlyPhase = 0f;

		private bool Exploded = false;

		private Color Color;

		public float FlyTime = 2.5f;

		private bool ClientSide = false;

		private static long CurrentTempID;

		private static long CurrentID;

		private static Dictionary<long, Rocket> Rockets;

		private static Dictionary<long, Rocket> TempRockets;

		private static Collider[] Colliders;

		private static MethodInfo GiantReactToNoise;

		private static MethodInfo DropPlayerBody;

		private static FieldInfo MouthDogAIHearNoiseCooldown;

		private static FieldInfo MouthDogAITimer;

		private static Dictionary<EnemyAI, float> IgnoringPlayers;

		private float lightPhase = 0f;

		static Rocket()
		{
			CurrentTempID = 1L;
			CurrentID = 1L;
			Rockets = new Dictionary<long, Rocket>();
			TempRockets = new Dictionary<long, Rocket>();
			Colliders = (Collider[])(object)new Collider[100];
			GiantReactToNoise = typeof(ForestGiantAI).GetMethod("ReactToNoise", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			DropPlayerBody = typeof(ForestGiantAI).GetMethod("StopKillAnimation", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			MouthDogAIHearNoiseCooldown = typeof(MouthDogAI).GetField("hearNoiseCooldown", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			MouthDogAITimer = typeof(MouthDogAI).GetField("AITimer", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			IgnoringPlayers = new Dictionary<EnemyAI, float>();
			AdvancedCompany.Network.Manager.AddListener(delegate(SpawnRocketFromClient msg)
			{
				//IL_000e: 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_0032: Unknown result type (might be due to invalid IL or missing references)
				SpawnOnAllClients(msg.PlayerNum, msg.TempID, msg.Position, msg.Rotation, msg.TurbulenceTime, msg.TurbulenceSpeed, msg.TurbulenceStrength, msg.FlyTime, msg.Color, msg.Time, !NetworkManager.Singleton.IsServer);
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(SpawnRocket msg)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				SpawnNetwork(msg.PlayerNum, msg.TempID, msg.ID, msg.Position, msg.Rotation, msg.TurbulenceTime, msg.TurbulenceSpeed, msg.TurbulenceStrength, msg.FlyTime, msg.Color, msg.Time, !NetworkManager.Singleton.IsServer);
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(RocketExplode msg)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Explode(msg.ID, msg.Position);
			});
		}

		public static void LoadAssets(AssetBundle assets)
		{
			RocketAsset = assets.LoadAsset<GameObject>("Assets/Prefabs/Objects/Rocket.prefab");
		}

		public static void Spawn(Vector3 position, Quaternion rotation)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			long tempID = CurrentTempID++;
			float turbulenceTime = Random.Range(10f, 100f);
			float turbulenceSpeed = Random.Range(0.01f, 0.1f);
			float turbulenceStrength = Random.Range(0.5f, 10f);
			float flyTime = Random.Range(2f, 3f);
			NetworkTime localTime = NetworkManager.Singleton.LocalTime;
			SpawnLocal(tempID, position, rotation, turbulenceTime, turbulenceSpeed, turbulenceStrength, flyTime, ((NetworkTime)(ref localTime)).Time, Color.HSVToRGB(Random.Range(0f, 1f), 1f, 1f), !NetworkManager.Singleton.IsServer);
		}

		private static void SpawnNetwork(int playerNum, long tempID, long ID, Vector3 position, Quaternion rotation, float turbulenceTime, float turbulenceSpeed, float turbulenceStrength, float flyTime, Color color, double time, bool clientSide = false)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0099: Unknown result type (might be due to invalid IL or missing references)
			if (playerNum == (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				if (TempRockets.ContainsKey(tempID))
				{
					Rocket rocket = TempRockets[tempID];
					rocket.ID = ID;
					Rockets.Add(ID, rocket);
					TempRockets.Remove(tempID);
				}
			}
			else if (!Rockets.ContainsKey(ID))
			{
				GameObject val = Object.Instantiate<GameObject>(RocketAsset, position, rotation);
				Rocket rocket2 = val.AddComponent<Rocket>();
				rocket2.ID = ID;
				rocket2.CalculatePath(position, rotation, turbulenceTime, turbulenceSpeed, turbulenceStrength, flyTime, color, time, clientSide: true);
				Rockets.Add(ID, rocket2);
			}
		}

		private static void SpawnOnAllClients(int playerNum, long tempID, Vector3 position, Quaternion rotation, float turbulenceTime, float turbulenceSpeed, float turbulenceStrength, float flyTime, Color color, double time, bool clientSide = false)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			long num = CurrentID++;
			GameObject val = Object.Instantiate<GameObject>(RocketAsset, position, rotation);
			Rocket rocket = val.AddComponent<Rocket>();
			rocket.TempID = tempID;
			rocket.ID = num;
			rocket.CalculatePath(position, rotation, turbulenceTime, turbulenceSpeed, turbulenceStrength, flyTime, color, time);
			Rockets.Add(num, rocket);
			AdvancedCompany.Network.Manager.Send(new SpawnRocket
			{
				PlayerNum = playerNum,
				TempID = tempID,
				ID = num,
				Position = position,
				Rotation = rotation,
				TurbulenceTime = turbulenceTime,
				TurbulenceSpeed = turbulenceSpeed,
				TurbulenceStrength = turbulenceStrength,
				FlyTime = flyTime,
				Color = color,
				Time = time
			}, 0uL);
		}

		public static void SpawnLocal(long tempID, Vector3 position, Quaternion rotation, float turbulenceTime, float turbulenceSpeed, float turbulenceStrength, float flyTime, double time, Color color, bool clientSide = false)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (clientSide)
			{
				GameObject val = Object.Instantiate<GameObject>(RocketAsset, position, rotation);
				Rocket rocket = val.AddComponent<Rocket>();
				rocket.TempID = tempID;
				rocket.CalculatePath(position, rotation, turbulenceTime, turbulenceSpeed, turbulenceStrength, flyTime, color, time, clientSide: true);
				TempRockets.Add(tempID, rocket);
				AdvancedCompany.Network.Manager.Send(new SpawnRocketFromClient
				{
					PlayerNum = (int)GameNetworkManager.Instance.localPlayerController.playerClientId,
					TempID = tempID,
					Position = position,
					Rotation = rotation,
					TurbulenceTime = turbulenceTime,
					TurbulenceSpeed = turbulenceSpeed,
					TurbulenceStrength = turbulenceStrength,
					FlyTime = flyTime,
					Color = color,
					Time = time
				}, 0uL);
			}
			else
			{
				SpawnOnAllClients((int)GameNetworkManager.Instance.localPlayerController.playerClientId, tempID, position, rotation, turbulenceTime, turbulenceSpeed, turbulenceStrength, flyTime, color, time);
			}
		}

		public static void Explode(long ID, Vector3 position)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (Rockets.ContainsKey(ID))
			{
				Rockets[ID].Explode(position);
				Rockets.Remove(ID);
			}
		}

		public void OnDestroy()
		{
			Rockets.Remove(ID);
		}

		public void CalculatePath(Vector3 position, Quaternion rotation, float turbulenceTime, float turbulenceSpeed, float turbulenceStrength, float flyTime, Color color, double time, bool clientSide = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: 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_026c: 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_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			Color = color;
			FlyTime = flyTime;
			ClientSide = clientSide;
			float num = 90f;
			float num2 = 0.2f;
			AnimationCurve val = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
			{
				new Keyframe(0f, 0f),
				new Keyframe(1f, 1f)
			});
			float num3 = 1f;
			float num4 = 1f;
			float num5 = 0f;
			List<Vector3> list = new List<Vector3> { position };
			Quaternion val2 = rotation;
			int num6 = 0;
			Vector3 val3 = list[0];
			float num7 = 4f;
			float num8 = num;
			while (num6 < 100)
			{
				float num9 = Mathf.Clamp01((float)num6 / turbulenceTime);
				float num10 = val.Evaluate(num9) * turbulenceStrength * num7;
				num5 += MathF.PI * turbulenceSpeed * num7;
				Vector3 val4 = val3 + val2 * new Vector3(0f, num7 * (num8 / 100f), 0f) + new Vector3(0f, (0f - num7) * ((100f - num8) / 100f), 0f);
				Vector3 val5 = val4 - val3;
				Quaternion val6 = ((val5 == Vector3.zero) ? Quaternion.identity : Quaternion.LookRotation(((Vector3)(ref val5)).normalized));
				Vector3 val7 = val6 * new Vector3(1f, 0f, 0f) * (Mathf.Cos(num5) * num10);
				Vector3 val8 = val6 * new Vector3(0f, 1f, 0f) * (Mathf.Sin(num5) * num10);
				list.Add(val4 + val7 + val8);
				val3 = val4;
				num6++;
				num8 -= num2;
			}
			num6 = 0;
			val3 = position;
			val2 = Quaternion.LookRotation(position + rotation * new Vector3(0f, 1f, 0f) - position);
			float num11 = 0.1f;
			RocketPath = new List<(Vector3, Quaternion)> { (position, val2) };
			for (; num6 < 250; num6++)
			{
				if (num11 < 1f)
				{
					num11 += 0.01f;
				}
				Vector3 val9 = val3 + val2 * new Vector3(0f, 0f, num11);
				Vector3 val10 = val3 + val2 * new Vector3(0f, 0f, num3);
				Vector3 val11 = val10;
				float num12 = 99999f;
				for (int i = 0; i < list.Count - 1; i++)
				{
					Vector3? val12 = ClosestPoint(list[i], list[i + 1], val10);
					if (val12.HasValue)
					{
						Vector3 val13 = val12.Value - val10;
						float sqrMagnitude = ((Vector3)(ref val13)).sqrMagnitude;
						if (sqrMagnitude < num12)
						{
							num12 = sqrMagnitude;
							val11 = val12.Value;
						}
					}
				}
				Vector3 val14 = val11 - val3;
				Quaternion val15 = ((val14 == Vector3.zero) ? Quaternion.identity : Quaternion.LookRotation(val14));
				val2 = Quaternion.RotateTowards(val2, val15, num4);
				val3 = val9;
				RocketPath.Add((val9, val2));
			}
			NetworkTime localTime = NetworkManager.Singleton.LocalTime;
			FlyPhase = (float)(((NetworkTime)(ref localTime)).Time - time);
		}

		private static Vector3? ClosestPoint(Vector3 a, Vector3 b, Vector3 p)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			float num = Vector3.Distance(a, b);
			Vector3 val = b - a;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num2 = Vector3.Dot(normalized, p - a);
			if (num2 < 0f || num2 > num)
			{
				return null;
			}
			return a + normalized * Mathf.Clamp(num2, 0f, num);
		}

		private void Start()
		{
			Smoke = ((Component)((Component)this).transform.Find("Smoke")).GetComponent<ParticleSystem>();
			Fireworks = ((Component)((Component)this).transform.Find("Firework")).GetComponent<ParticleSystem>();
			FireworkLight = ((Component)Fireworks).GetComponent<Light>();
			FireworkLightData = ((Component)Fireworks).GetComponent<HDAdditionalLightData>();
			Model = ((Component)((Component)this).transform.Find("Model")).gameObject;
			Audio = ((Component)this).GetComponent<AudioSource>();
			FireworkAudio = ((Component)Fireworks).GetComponent<AudioSource>();
			Smoke.Play();
			Audio.Play();
		}

		private IEnumerator DelayedDestroy()
		{
			yield return (object)new WaitForSeconds(5f);
			Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
		}

		private void OnTriggerEnter(Collider other)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!other.isTrigger && !ClientSide && !Exploded)
			{
				Exploded = true;
				AdvancedCompany.Network.Manager.Send(new RocketExplode
				{
					ID = ID,
					Position = ((Component)this).transform.position
				}, 0uL);
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "GetAllPlayersInLineOfSight")]
		[HarmonyPrefix]
		public static bool LineOfSight(EnemyAI __instance, PlayerControllerB[] __result)
		{
			if (IgnoringPlayers.ContainsKey(__instance))
			{
				__result = (PlayerControllerB[])(object)new PlayerControllerB[0];
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyAI), "GetClosestPlayer")]
		[HarmonyPrefix]
		public static bool ClosestPlayer(EnemyAI __instance, PlayerControllerB __result)
		{
			if (IgnoringPlayers.ContainsKey(__instance))
			{
				__result = null;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(RoundManager), "Update")]
		[HarmonyPrefix]
		public static void UpdateEnemyTimers()
		{
			List<EnemyAI> list = IgnoringPlayers.Keys.ToList();
			for (int i = 0; i < list.Count; i++)
			{
				IgnoringPlayers[list[i]] -= Time.deltaTime;
				if (IgnoringPlayers[list[i]] < 0f)
				{
					IgnoringPlayers.Remove(list[i]);
					continue;
				}
				EnemyAI obj = list[i];
				ForestGiantAI val = (ForestGiantAI)(object)((obj is ForestGiantAI) ? obj : null);
				if (val != null)
				{
					val.chasingPlayer = null;
				}
			}
		}

		[HarmonyPatch(typeof(ForestGiantAI), "OnCollideWithPlayer")]
		[HarmonyPrefix]
		public static bool IgnoreCollision(ForestGiantAI __instance)
		{
			if (IgnoringPlayers.ContainsKey((EnemyAI)(object)__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(ForestGiantAI), "BeginChasingNewPlayerClientRpc")]
		[HarmonyPrefix]
		public static bool IgnoreChase(ForestGiantAI __instance)
		{
			if (IgnoringPlayers.ContainsKey((EnemyAI)(object)__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(ForestGiantAI), "BeginEatPlayer")]
		[HarmonyPrefix]
		public static bool IgnoreEat(ForestGiantAI __instance)
		{
			if (IgnoringPlayers.ContainsKey((EnemyAI)(object)__instance))
			{
				return false;
			}
			return true;
		}

		public static void IgnorePlayers(EnemyAI enemy, float time)
		{
			IgnoringPlayers[enemy] = time;
		}

		public void Explode(Vector3 position)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((Component)this).transform.position = position;
				Smoke.Stop();
				Audio.Stop();
				Model.SetActive(false);
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				Color.RGBToHSV(Color, ref num, ref num2, ref num3);
				float num4 = default(float);
				float num5 = default(float);
				float num6 = default(float);
				Color.RGBToHSV(Color, ref num4, ref num5, ref num6);
				Color val = Color.HSVToRGB(num - 0.1f, num2, num3);
				Color val2 = Color.HSVToRGB(num4 + 0.1f, num2, num3);
				Exploded = true;
				((Behaviour)FireworkLight).enabled = true;
				FireworkLightData.lightUnit = (LightUnit)1;
				FireworkLightData.range = 12f;
				FireworkLightData.color = Color;
				FireworkLightData.enableSpotReflector = true;
				FireworkLightData.volumetricDimmer = 10f;
				FireworkLightData.lightDimmer = 10f;
				FireworkLightData.interactsWithSky = true;
				FireworkLightData.intensity = 800000f;
				float num7 = Vector3.Distance(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, ((Component)this).transform.position);
				float num8 = Mathf.Clamp(Mathf.Pow(num7 / 200f, 0.5f), 0.1f, 1.5f);
				MainModule main = Fireworks.main;
				((MainModule)(ref main)).startColor = new MinMaxGradient(val, val2);
				MinMaxCurve startSize = ((MainModule)(ref main)).startSize;
				float num9 = ((MinMaxCurve)(ref startSize)).constantMin * num8;
				startSize = ((MainModule)(ref main)).startSize;
				((MainModule)(ref main)).startSize = new MinMaxCurve(num9, ((MinMaxCurve)(ref startSize)).constantMax * num8);
				CollisionModule collision = Fireworks.collision;
				((CollisionModule)(ref collision)).radiusScale = num8;
				SubEmittersModule subEmitters = Fireworks.subEmitters;
				for (int i = 0; i < ((SubEmittersModule)(ref subEmitters)).subEmittersCount; i++)
				{
					ParticleSystem subEmitterSystem = ((SubEmittersModule)(ref subEmitters)).GetSubEmitterSystem(i);
					MainModule main2 = subEmitterSystem.main;
					startSize = ((MainModule)(ref main2)).startSize;
					float num10 = ((MinMaxCurve)(ref startSize)).constantMin * num8;
					startSize = ((MainModule)(ref main2)).startSize;
					((MainModule)(ref main2)).startSize = new MinMaxCurve(num10, ((MinMaxCurve)(ref startSize)).constantMax * num8);
				}
				Collider[] array = (Collider[])(object)new Collider[100];
				int num11 = Physics.OverlapSphereNonAlloc(((Component)this).transform.position, 500f, Colliders, 8912896);
				Vector3 val3 = ((Component)this).transform.position;
				RaycastHit val4 = default(RaycastHit);
				if (Physics.Raycast(val3, Vector3.down, ref val4, 200f, 268437760, (QueryTriggerInteraction)1))
				{
					val3 = ((RaycastHit)(ref val4)).point;
				}
				MouthDogAI val5 = default(MouthDogAI);
				ForestGiantAI val6 = default(ForestGiantAI);
				INoiseListener val7 = default(INoiseListener);
				for (int j = 0; j < num11; j++)
				{
					if (((Component)((Component)Colliders[j]).transform).TryGetComponent<MouthDogAI>(ref val5))
					{
						if (!((EnemyAI)val5).isEnemyDead)
						{
							((EnemyAI)val5).destination = val3;
							((EnemyAI)val5).moveTowardsDestination = true;
							((EnemyAI)val5).movingTowardsTargetPlayer = false;
							val5.suspicionLevel = 9;
							MouthDogAITimer.SetValue(val5, 10f);
							MouthDogAIHearNoiseCooldown.SetValue(val5, 10f);
							((EnemyAI)val5).SwitchToBehaviourState(1);
							IgnorePlayers((EnemyAI)(object)val5, 7f);
						}
					}
					else if (((Component)((Component)Colliders[j]).transform).TryGetComponent<ForestGiantAI>(ref val6))
					{
						((EnemyAI)val6).SwitchToBehaviourState(0);
						((EnemyAI)val6).destination = val3;
						((EnemyAI)val6).moveTowardsDestination = true;
						((EnemyAI)val6).movingTowardsTargetPlayer = false;
						val6.timeSpentStaring = 10f;
						val6.chasingPlayer = null;
						val6.investigatePosition = RoundManager.Instance.GetNavMeshPosition(val3, default(NavMeshHit), 5f, -1);
						val6.investigating = true;
						GiantReactToNoise.Invoke(val6, new object[2] { -4f, val3 });
						DropPlayerBody.Invoke(val6, new object[0]);
						IgnorePlayers((EnemyAI)(object)val6, 5f);
					}
					else if (((Component)((Component)Colliders[j]).transform).TryGetComponent<INoiseListener>(ref val7))
					{
						val7.DetectNoise(val3, 10f, 0, 9999);
					}
				}
				num11 = Physics.OverlapSphereNonAlloc(((Component)this).transform.position, 3f, Colliders, 1051400);
				for (int k = 0; k < num11; k++)
				{
					if (((Component)((Component)Colliders[k]).transform).CompareTag("Player"))
					{
						PlayerControllerB component = ((Component)Colliders[k]).GetComponent<PlayerControllerB>();
						if ((Object)(object)component == (Object)(object)GameNetworkManager.Instance.localPlayerController)
						{
							float num12 = Vector3.Distance(((Component)Colliders[k]).transform.position, ((Component)this).transform.position);
							component.DamagePlayer((int)num12 * 5, false, true, (CauseOfDeath)3, 0, false, default(Vector3));
						}
					}
				}
				RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 1000f, 1000f, 0, false, 9999);
				Fireworks.Play();
				FireworkAudio.Play();
				((MonoBehaviour)this).StartCoroutine(DelayedDestroy());
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while exploding rocket!");
				Plugin.Log.LogError((object)ex);
			}
		}

		private void Update()
		{
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if (((Behaviour)FireworkLight).enabled)
			{
				lightPhase += Time.deltaTime / 2f;
				FireworkLightData.range = Mathf.SmoothStep(25f, 0f, Mathf.Clamp01(lightPhase / 0.7f - 0.3f));
				FireworkLightData.shapeRadius = Mathf.SmoothStep(30f, 150f, Mathf.Clamp01(lightPhase * 2f));
				FireworkLightData.intensity = Mathf.SmoothStep(800000f, 100000f, Mathf.Clamp01(lightPhase / 0.5f - 0.5f));
				if (FireworkLightData.range <= 0.01f)
				{
					((Behaviour)FireworkLight).enabled = false;
				}
			}
			if (Exploded || (ClientSide && FlyPhase >= FlyTime))
			{
				return;
			}
			Quaternion val = Quaternion.Euler(90f, 0f, 0f);
			FlyPhase += Time.deltaTime;
			if (FlyPhase >= FlyTime)
			{
				if (!ClientSide)
				{
					Exploded = true;
					AdvancedCompany.Network.Manager.Send(new RocketExplode
					{
						ID = ID,
						Position = ((Component)this).transform.position
					}, 0uL);
				}
			}
			else
			{
				float num = FlyPhase / FlyTime;
				int num2 = (int)((float)(RocketPath.Count - 2) * num);
				float num3 = num * (float)(RocketPath.Count - 2) - (float)num2;
				((Component)this).transform.position = RocketPath[num2].Item1 + (RocketPath[num2 + 1].Item1 - RocketPath[num2].Item1) * num3;
				((Component)this).transform.rotation = Quaternion.Lerp(RocketPath[num2].Item2, RocketPath[num2 + 1].Item2, num3) * val;
			}
		}
	}
	[LoadAssets]
	internal class RocketBoots : Boots, IPerformJump, IOnUpdate
	{
		private static FieldInfo isJumping;

		private static FieldInfo isFallingFromJump;

		private static GameObject LeftRocketBoot;

		private static GameObject RightRocketBoot;

		private static AudioClip RocketBootsAudio;

		public bool DoubleJumpAvailable = false;

		public bool DoubleJumpExecuted = false;

		public override AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.HIDE_FEET;
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			Transform[] bones = (Transform[])(object)new Transform[5]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_FOOT),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_SHIN),
				player.GetBone(AdvancedCompany.Game.Player.Bone.L_THIGH)
			};
			Transform[] bones2 = (Transform[])(object)new Transform[5]
			{
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_TOE),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_HEEL),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_FOOT),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_SHIN),
				player.GetBone(AdvancedCompany.Game.Player.Bone.R_THIGH)
			};
			Transform bone = player.GetBone(AdvancedCompany.Game.Player.Bone.METARIG);
			GameObject val = Object.Instantiate<GameObject>(LeftRocketBoot, bone);
			val.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.L_THIGH);
			val.GetComponent<SkinnedMeshRenderer>().bones = bones;
			((Renderer)val.GetComponent<SkinnedMeshRenderer>()).ResetBounds();
			GameObject val2 = Object.Instantiate<GameObject>(RightRocketBoot, bone);
			val2.GetComponent<SkinnedMeshRenderer>().rootBone = player.GetBone(AdvancedCompany.Game.Player.Bone.R_THIGH);
			val2.GetComponent<SkinnedMeshRenderer>().bones = bones2;
			((Renderer)val2.GetComponent<SkinnedMeshRenderer>()).ResetBounds();
			if (player.IsLocal)
			{
				val.layer = 23;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val3 in array)
				{
					((Component)val3).gameObject.layer = 23;
				}
				val2.layer = 23;
				componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array2 = componentsInChildren;
				foreach (Transform val4 in array2)
				{
					((Component)val4).gameObject.layer = 23;
				}
			}
			return (GameObject[])(object)new GameObject[2] { val, val2 };
		}

		public static void LoadAssets(AssetBundle assets)
		{
			LeftRocketBoot = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/RocketBootsLeft.prefab");
			RightRocketBoot = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/RocketBootsRight.prefab");
			RocketBootsAudio = assets.LoadAsset<AudioClip>("Assets/Sounds/RocketBoots.mp3");
		}

		static RocketBoots()
		{
			isJumping = AccessTools.Field(typeof(PlayerControllerB), "isJumping");
			isFallingFromJump = AccessTools.Field(typeof(PlayerControllerB), "isFallingFromJump");
			AdvancedCompany.Network.Manager.AddListener(delegate(RocketJump msg)
			{
				for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
					if ((int)val.playerClientId == msg.PlayerNum)
					{
						if (msg.PlayerNum != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
						{
							((Component)val).GetComponent<PlayerRocketBoots>().PlayParticles();
						}
						val.movementAudio.PlayOneShot(RocketBootsAudio);
					}
				}
			});
		}

		public void OnUpdate(AdvancedCompany.Game.Player player)
		{
			if (!player.IsOwner)
			{
				return;
			}
			if (!player.IsGrounded && player.FallValue < 6f && player.IsFallingNoJump && !player.IsFallingFromJump && !player.IsJumping)
			{
				if (!DoubleJumpAvailable && !DoubleJumpExecuted)
				{
					DoubleJumpAvailable = true;
				}
			}
			else if (player.IsGrounded && !player.IsJumping && !player.IsFallingFromJump)
			{
				DoubleJumpExecuted = false;
				if (DoubleJumpAvailable)
				{
					DoubleJumpAvailable = false;
				}
			}
		}

		public bool PerformJump(AdvancedCompany.Game.Player player)
		{
			bool flag = player.IsJumping || player.IsFallingFromJump;
			if (!DoubleJumpExecuted && !player.QuickMenuManager.isMenuOpen && ((player.IsOwner && player.IsPlayerControlled && (!player.IsServer || player.IsHostPlayerObject)) || player.IsTestingPlayer))
			{
				if (!DoubleJumpAvailable && !flag)
				{
					DoubleJumpAvailable = true;
				}
				else if (!player.InSpecialInteractAnimation && !player.IsTypingChat && (player.IsMovementHindered <= 0 || player.IsUnderwater) && !player.IsCrouching && DoubleJumpAvailable && player.FallValue < 6f)
				{
					player.FallValue = Mathf.Max(player.FallValue, 0f) + player.JumpForce * 2f;
					player.FallValueUncapped = player.FallValue;
					player.IsFallingFromJump = false;
					player.IsFallingNoJump = true;
					DoubleJumpAvailable = false;
					DoubleJumpExecuted = true;
					AdvancedCompany.Network.Manager.Send(new RocketJump
					{
						PlayerNum = player.PlayerNum
					}, 0uL);
				}
			}
			return true;
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class TacticalHelmet : WalkieTalkie, IEquipmentCommunication, IHelmet, IClothing, IEquipmentFlashlight
	{
		private static GameObject HelmetPrefab;

		private Material Material;

		private Light Light1;

		private Light Light2;

		private float StrengthTarget = 1f;

		private float Strength = 1f;

		private float StrengthTime = 0.5f;

		private float StrengthPhase = 1f;

		private float Phase = 0f;

		public bool isFlashlightBeingUsed = false;

		private bool Speaking = false;

		public bool CanUnequip()
		{
			return true;
		}

		public virtual AdvancedCompany.Game.Player.BodyLayers GetLayers()
		{
			return AdvancedCompany.Game.Player.BodyLayers.NONE;
		}

		static TacticalHelmet()
		{
			AdvancedCompany.Network.Manager.AddListener(delegate(ActivateTacticalHelmet msg)
			{
				if (msg.PlayerNum != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(msg.PlayerNum);
					if (player.Helmet is TacticalHelmet tacticalHelmet)
					{
						tacticalHelmet.SwitchFlashlight(player, msg.IsUsed);
					}
				}
			});
		}

		public bool IsUsed()
		{
			return isFlashlightBeingUsed;
		}

		public override void Start()
		{
			base.thisAudio = ((Component)this).GetComponent<AudioSource>();
			base.target = ((Component)((Component)this).transform.Find("Target")).GetComponent<AudioSource>();
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (items.itemName == "Walkie-talkie")
				{
					WalkieTalkie component = items.spawnPrefab.GetComponent<WalkieTalkie>();
					base.talkingOnWalkieTalkieNotHeldSFX = component.talkingOnWalkieTalkieNotHeldSFX;
					base.switchWalkieTalkiePowerOn = component.switchWalkieTalkiePowerOn;
					base.switchWalkieTalkiePowerOff = component.switchWalkieTalkiePowerOff;
					base.stopTransmissionSFX = component.stopTransmissionSFX;
					base.startTransmissionSFX = component.startTransmissionSFX;
					base.recordingRange = component.recordingRange;
					base.playerDieOnWalkieTalkieSFX = component.playerDieOnWalkieTalkieSFX;
					break;
				}
			}
			((WalkieTalkie)this).Start();
		}

		public override void EquipItem()
		{
			if (((NetworkBehaviour)this).IsOwner)
			{
				HUDManager.Instance.ClearControlTips();
				((GrabbableObject)this).SetControlTipsForItem();
			}
			((GrabbableObject)this).EnableItemMeshes(true);
			((GrabbableObject)this).isPocketed = false;
			if (!((GrabbableObject)this).hasBeenHeld)
			{
				((GrabbableObject)this).hasBeenHeld = true;
				if (!((GrabbableObject)this).isInShipRoom && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.currentLevel.spawnEnemiesAndScrap)
				{
					RoundManager instance = RoundManager.Instance;
					instance.valueOfFoundScrapItems += ((GrabbableObject)this).scrapValue;
				}
			}
		}

		public override void PocketItem()
		{
			if (((NetworkBehaviour)this).IsOwner && (Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
			{
				((GrabbableObject)this).playerHeldBy.IsInspectingItem = false;
			}
			((GrabbableObject)this).isPocketed = true;
			((GrabbableObject)this).EnableItemMeshes(false);
			((Component)this).gameObject.GetComponent<AudioSource>().PlayOneShot(((GrabbableObject)this).itemProperties.pocketSFX, 1f);
		}

		public static void Initialize()
		{
		}

		public override void Update()
		{
			((WalkieTalkie)this).Update();
			if (isFlashlightBeingUsed)
			{
				Battery insertedBattery = ((GrabbableObject)this).insertedBattery;
				insertedBattery.charge += Time.deltaTime / ServerConfiguration.Instance.Items.TacticalHelmet.BatteryTime - Time.deltaTime / ServerConfiguration.Instance.Items.TacticalHelmet.BatteryTimeWithLight;
				if ((Object)(object)Light1 != (Object)null && !((Behaviour)Light1).enabled)
				{
					((Behaviour)Light1).enabled = true;
				}
				if ((Object)(object)Light2 != (Object)null && !((Behaviour)Light2).enabled)
				{
					((Behaviour)Light2).enabled = true;
				}
				Phase = Mathf.Clamp01(Phase + Time.deltaTime * 5f);
				if (StrengthPhase >= 1f)
				{
					StrengthTime = Random.Range(0.1f, 0.3f);
					StrengthTarget = Random.Range(0.95f, 1.12f);
					Strength = StrengthTarget;
					StrengthPhase = 0f;
				}
				else
				{
					float num = Strength + (StrengthTarget - Strength) * StrengthPhase;
					StrengthPhase += Time.deltaTime / StrengthTime;
					if ((Object)(object)Light1 != (Object)null)
					{
						Light1.intensity = 100f * Phase * num;
					}
					if ((Object)(object)Light2 != (Object)null)
					{
						Light2.intensity = 100f * Phase * num;
					}
				}
			}
			else
			{
				if ((Object)(object)Light1 != (Object)null && ((Behaviour)Light1).enabled)
				{
					((Behaviour)Light1).enabled = false;
				}
				if ((Object)(object)Light2 != (Object)null && ((Behaviour)Light2).enabled)
				{
					((Behaviour)Light2).enabled = false;
				}
				Phase = Mathf.Clamp01(Phase - Time.deltaTime * 5f);
			}
			if ((Object)(object)Material != (Object)null)
			{
				Material.SetFloat("_EmissiveExposureWeight", 2f - Phase * 2f);
			}
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
			((GrabbableObject)this).isBeingUsed = false;
			isFlashlightBeingUsed = false;
			((WalkieTalkie)this).DiscardItem();
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (IsEquipped())
			{
				Unequip();
			}
			else
			{
				Equip();
			}
		}

		public GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(HelmetPrefab, player.GetBone(AdvancedCompany.Game.Player.Bone.SPINE_3));
			val.transform.localPosition = new Vector3(0f, 0.013f, 0.062f);
			val.transform.localRotation = Quaternion.Euler(-96.48f, 0f, 0f);
			val.transform.localScale = new Vector3(0.00794f, 0.00794f, 0.00794f);
			Light[] componentsInChildren = val.GetComponentsInChildren<Light>();
			Light1 = componentsInChildren[0];
			Light2 = componentsInChildren[1];
			Renderer component = val.GetComponent<Renderer>();
			Material = component.material;
			if (player.IsLocal)
			{
				val.layer = 23;
				((Component)Light1).transform.parent = ((Component)player.Controller.gameplayCamera).transform;
				((Component)Light2).transform.parent = ((Component)player.Controller.gameplayCamera).transform;
				((Component)Light1).transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
				((Component)Light2).transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
				((Component)Light1).transform.localPosition = new Vector3(-0.4f, 0.3f, 0.15f);
				((Component)Light2).transform.localPosition = new Vector3(0.4f, 0.3f, 0.15f);
				return (GameObject[])(object)new GameObject[3]
				{
					val,
					((Component)Light1).gameObject,
					((Component)Light2).gameObject
				};
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public override void UseUpBatteries()
		{
			((GrabbableObject)this).isBeingUsed = false;
			isFlashlightBeingUsed = false;
			if ((Object)(object)Light1 != (Object)null)
			{
				((Behaviour)Light1).enabled = false;
			}
			if ((Object)(object)Light2 != (Object)null)
			{
				((Behaviour)Light2).enabled = false;
			}
			base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOff);
			if (((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie)
			{
				((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			HelmetPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/TacticalHelmet.prefab");
		}

		public bool CanBeUsed()
		{
			if (((GrabbableObject)this).insertedBattery != null && ((GrabbableObject)this).insertedBattery.charge > 0f)
			{
				return true;
			}
			return false;
		}

		public void SwitchTalking(AdvancedCompany.Game.Player player, bool talking)
		{
			Speaking = talking;
			if (talking)
			{
				((MonoBehaviour)this).StartCoroutine(Speak());
			}
		}

		private IEnumerator Speak()
		{
			base.speakingIntoWalkieTalkie = true;
			base.previousPlayerHeldBy.activatingItem = true;
			((WalkieTalkie)this).SetLocalClientSpeaking(true);
			yield return (object)new WaitForSeconds(0.2f);
			yield return (object)new WaitUntil((Func<bool>)(() => !Speaking || !((GrabbableObject)this).isBeingUsed));
			((WalkieTalkie)this).SetLocalClientSpeaking(false);
			base.speakingIntoWalkieTalkie = false;
			base.previousPlayerHeldBy.activatingItem = false;
		}

		public virtual void Equipped(AdvancedCompany.Game.Player player)
		{
			((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = true;
			((GrabbableObject)this).playerHeldBy = player.Controller;
			base.previousPlayerHeldBy = player.Controller;
			base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOn);
			((GrabbableObject)this).isBeingUsed = true;
		}

		public void Equip()
		{
			AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				FromSlot = ((GrabbableObject)this).playerHeldBy.currentItemSlot,
				ToSlot = GetEquipmentSlot()
			}, 0uL);
		}

		public void Unequipped(AdvancedCompany.Game.Player player)
		{
			try
			{
				base.thisAudio.PlayOneShot(base.switchWalkieTalkiePowerOff);
				((GrabbableObject)this).playerHeldBy.holdingWalkieTalkie = false;
				if (base.speakingIntoWalkieTalkie)
				{
					((WalkieTalkie)this).SetLocalClientSpeaking(false);
				}
				((GrabbableObject)this).isBeingUsed = false;
				isFlashlightBeingUsed = false;
			}
			catch (Exception)
			{
			}
		}

		public void Unequip()
		{
			if (!((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null))
			{
				return;
			}
			int num = Perks.InventorySlotsOf(((GrabbableObject)this).playerHeldBy);
			int num2 = -1;
			for (int i = 0; i < num; i++)
			{
				if ((Object)(object)((GrabbableObject)this).playerHeldBy.ItemSlots[i] == (Object)null)
				{
					num2 = i;
					break;
				}
			}
			if (num2 == -1)
			{
				((GrabbableObject)this).DiscardItem();
				return;
			}
			AdvancedCompany.Network.Manager.Send(new ChangeItemSlot
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				FromSlot = ((GrabbableObject)this).playerHeldBy.currentItemSlot,
				ToSlot = num2
			}, 0uL);
		}

		public int GetEquipmentSlot()
		{
			return 10;
		}

		public bool IsEquipped()
		{
			int equipmentSlot = GetEquipmentSlot();
			if (equipmentSlot == -1)
			{
				return false;
			}
			if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null)
			{
				return (Object)(object)((GrabbableObject)this).playerHeldBy.ItemSlots[equipmentSlot] == (Object)(object)this;
			}
			return false;
		}

		public void SwitchFlashlight(AdvancedCompany.Game.Player player, bool on)
		{
			if (!on || !(((GrabbableObject)this).insertedBattery.charge <= 0f))
			{
				if (player.IsLocal)
				{
					AdvancedCompany.Network.Manager.Send(new ActivateTacticalHelmet
					{
						PlayerNum = player.PlayerNum,
						IsUsed = on
					}, 0uL);
				}
				isFlashlightBeingUsed = on;
			}
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	internal class VisionEnhancer : Helmet, IEquipmentFlashlight
	{
		private static GameObject NightVisionPrefab;

		private Transform Goggles;

		private GameObject PlayerLight;

		private Volume Volume;

		private static AdvancedCompany.PostProcessing.VisionEnhancer Effect;

		private float Phase = 0f;

		static VisionEnhancer()
		{
			AdvancedCompany.Network.Manager.AddListener(delegate(ActivateVisionEnhancer msg)
			{
				if (msg.PlayerNum != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
				{
					AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(msg.PlayerNum);
					if (player.Helmet is VisionEnhancer visionEnhancer)
					{
						visionEnhancer.SwitchFlashlight(player, msg.IsUsed);
					}
				}
			});
		}

		public override void Start()
		{
			((GrabbableObject)this).Start();
		}

		public static void Initialize()
		{
		}

		public override void Update()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			if (((GrabbableObject)this).isBeingUsed)
			{
				Phase = Mathf.Clamp01(Phase + Time.deltaTime * 5f);
			}
			else
			{
				Phase = Mathf.Clamp01(Phase - Time.deltaTime * 5f);
			}
			if ((Object)(object)Goggles != (Object)null)
			{
				((Component)Goggles).transform.localRotation = Quaternion.Euler(110f + 160f * Phase, 0f, 0f);
			}
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			base.ItemActivate(used, buttonDown);
			((GrabbableObject)this).isBeingUsed = false;
		}

		public override void Unequipped(AdvancedCompany.Game.Player player)
		{
			((GrabbableObject)this).isBeingUsed = false;
			if (player.IsLocal)
			{
				VisionEnhancerEffect.Deactivate();
			}
		}

		public override GameObject[] CreateWearable(AdvancedCompany.Game.Player player)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			GameObject val = Object.Instantiate<GameObject>(NightVisionPrefab, player.HeadMount.transform);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
			Goggles = val.transform.Find("Goggles");
			((Component)Goggles).transform.localRotation = Quaternion.Euler(((GrabbableObject)this).isBeingUsed ? (-90f) : 110f, 0f, 0f);
			if (player.IsLocal)
			{
				val.layer = 23;
				Transform[] componentsInChildren = val.GetComponentsInChildren<Transform>();
				Transform[] array = componentsInChildren;
				foreach (Transform val2 in array)
				{
					((Component)val2).gameObject.layer = 23;
				}
			}
			return (GameObject[])(object)new GameObject[1] { val };
		}

		public bool IsUsed()
		{
			return ((GrabbableObject)this).isBeingUsed;
		}

		public override void UseUpBatteries()
		{
			((GrabbableObject)this).UseUpBatteries();
			((GrabbableObject)this).isBeingUsed = false;
			VisionEnhancerEffect.Deactivate();
			AdvancedCompany.Network.Manager.Send(new ActivateVisionEnhancer
			{
				PlayerNum = (int)((GrabbableObject)this).playerHeldBy.playerClientId,
				IsUsed = false
			}, 0uL);
		}

		public static void LoadAssets(AssetBundle assets)
		{
			NightVisionPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/VisionEnhancer.prefab");
		}

		public void SwitchFlashlight(AdvancedCompany.Game.Player player, bool on)
		{
			if (on && ((GrabbableObject)this).insertedBattery.charge <= 0f)
			{
				return;
			}
			if (player.IsLocal)
			{
				if (on)
				{
					VisionEnhancerEffect.Activate();
				}
				else
				{
					VisionEnhancerEffect.Deactivate();
				}
				AdvancedCompany.Network.Manager.Send(new ActivateVisionEnhancer
				{
					PlayerNum = player.PlayerNum,
					IsUsed = on
				}, 0uL);
			}
			((GrabbableObject)this).isBeingUsed = on;
		}

		public bool CanBeUsed()
		{
			if (((GrabbableObject)this).insertedBattery != null && ((GrabbableObject)this).insertedBattery.charge > 0f)
			{
				return true;
			}
			return false;
		}
	}
}
namespace AdvancedCompany.Objects.Interfaces
{
	internal interface IIconProvider
	{
		Sprite GetIcon();
	}
	internal interface IMovement
	{
		bool Movement(AdvancedCompany.Game.Player player);
	}
	internal interface IOnUpdate
	{
		void OnUpdate(AdvancedCompany.Game.Player player);
	}
	internal interface IPerformJump
	{
		bool PerformJump(AdvancedCompany.Game.Player player);
	}
}
namespace AdvancedCompany.Network
{
	internal static class Fletcher
	{
		private static IEnumerable<ulong> Blockify(IReadOnlyList<byte> inputAsBytes, int blockSize)
		{
			int i = 0;
			ulong block = 0uL;
			while (i < inputAsBytes.Count)
			{
				block = (block << 8) | inputAsBytes[i];
				i++;
				if (i % blockSize == 0 || i == inputAsBytes.Count)
				{
					yield return block;
					block = 0uL;
				}
			}
		}

		private static byte[] GetFletcher(IReadOnlyList<byte> input, int n = 32)
		{
			int num = n / 16;
			ulong num2 = (ulong)(System.Math.Pow(2.0, 8 * num) - 1.0);
			ulong num3 = 0uL;
			ulong num4 = 0uL;
			foreach (ulong item in Blockify(input, num))
			{
				num3 = (num3 + item) % num2;
				num4 = (num4 + num3) % num2;
			}
			return BitConverter.GetBytes(num3 + num4 * (num2 + 1));
		}
	}
	internal interface INamedMessage : ITransferable
	{
	}
	internal interface ITransferable
	{
		void WriteData(FastBufferWriter writer);

		void ReadData(FastBufferReader reader);
	}
	internal class Lobby : ITransferable
	{
		public static int LocalPlayerNum;

		public bool IsJoinable = true;

		public Ship CurrentShip;

		public Dictionary<int, AdvancedCompany.Game.Player> ConnectedPlayers = new Dictionary<int, AdvancedCompany.Game.Player>();

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

		public AdvancedCompany.Game.Player Player(int id)
		{
			if (ConnectedPlayers.ContainsKey(id))
			{
				return ConnectedPlayers[id];
			}
			return null;
		}

		public AdvancedCompany.Game.Player Player(ulong clientId)
		{
			foreach (KeyValuePair<int, AdvancedCompany.Game.Player> connectedPlayer in ConnectedPlayers)
			{
				if (connectedPlayer.Value.ClientID == clientId)
				{
					return connectedPlayer.Value;
				}
			}
			return null;
		}

		public AdvancedCompany.Game.Player Player(string name)
		{
			foreach (KeyValuePair<int, AdvancedCompany.Game.Player> connectedPlayer in ConnectedPlayers)
			{
				if (connectedPlayer.Value.Controller.playerUsername.Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					return connectedPlayer.Value;
				}
			}
			return null;
		}

		public AdvancedCompany.Game.Player Player()
		{
			if (ConnectedPlayers.ContainsKey(LocalPlayerNum))
			{
				return ConnectedPlayers[LocalPlayerNum];
			}
			return null;
		}

		public void ReadData(FastBufferReader reader)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			ConnectedPlayers.Clear();
			CurrentShip = new Ship();
			CurrentShip.ReadData(reader);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsJoinable, default(ForPrimitives));
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			int playerNum = default(int);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref playerNum, default(ForPrimitives));
				Plugin.Log.LogMessage((object)("Reading lobby data. Player " + playerNum));
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(playerNum);
				player.ReadData(reader);
				ConnectedPlayers[player.PlayerNum] = player;
			}
			int num2 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
			Plugin.Log.LogMessage((object)("Reading " + num2 + " late joiners."));
			LateJoiners = new List<int>();
			int item = default(int);
			for (int j = 0; j < num2; j++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref item, default(ForPrimitives));
				Plugin.Log.LogMessage((object)("Reading late joiner: " + item));
				LateJoiners.Add(item);
			}
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			CurrentShip.WriteData(writer);
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsJoinable, default(ForPrimitives));
			int count = ConnectedPlayers.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (KeyValuePair<int, AdvancedCompany.Game.Player> connectedPlayer in ConnectedPlayers)
			{
				count = connectedPlayer.Value.PlayerNum;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
				connectedPlayer.Value.WriteData(writer);
			}
			count = LateJoiners.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (int lateJoiner in LateJoiners)
			{
				int current2 = lateJoiner;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref current2, default(ForPrimitives));
			}
		}

		public void PlayerConnected(AdvancedCompany.Game.Player player, bool isLateJoiner = false)
		{
			Plugin.Log.LogInfo((object)("New player (" + player.PlayerNum + ") joined lobby."));
			ConnectedPlayers[player.PlayerNum] = player;
			if (isLateJoiner)
			{
				Plugin.Log.LogInfo((object)("Player " + player.PlayerNum + " joined late."));
				LateJoiners.Add(player.PlayerNum);
			}
		}

		public static int GetPlayerNum(ulong clientId)
		{
			if (LobbySizePatches.ConnectingClients.ContainsKey(clientId))
			{
				LobbyDataSynchronization syncHandler = LobbySizePatches.ConnectingClients[clientId].GetSyncHandler<LobbyDataSynchronization>();
				return syncHandler.PlayerNum;
			}
			throw new Exception("Error while receiving player num. There was no connecting client with ID: " + clientId);
		}

		public void PlayerDisconnected(int playerNum)
		{
			ConnectedPlayers.Remove(playerNum);
		}
	}
	[HarmonyPatch]
	internal class Manager
	{
		public delegate void PlayerConnected(ulong clientID);

		public delegate void PlayerDisconnected(ulong clientID, int playerNum);

		public delegate void Connected();

		public delegate void Disconnected();

		public delegate void Kicked(string reason);

		public delegate void LobbyCreated();

		public delegate void ReceivedLobby();

		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__NetworkManager_OnClientStarted;

			public static Action<bool> <1>__NetworkManager_OnClientStopped;

			public static Action <2>__NetworkManager_OnServerStarted;

			public static Action<bool> <3>__NetworkManager_OnServerStopped;

			public static HandleNamedMessageDelegate <4>__ReceiveNewPlayer;

			public static HandleNamedMessageDelegate <5>__ReceiveKick;
		}

		public const string NamePrefix = "AdvancedCompanyMod_";

		private static Dictionary<string, (Type Type, bool ServerOnly, bool IsRelay)> MessageTypes;

		private static Dictionary<string, List<(object, Action<INamedMessage>)>> Listeners;

		public static PlayerConnected OnPlayerConnected;

		public static PlayerDisconnected OnPlayerDisconnected;

		public static Connected OnConnected;

		public static Disconnected OnDisconnected;

		public static Kicked OnKicked;

		public static LobbyCreated OnLobbyCreated;

		public static ReceivedLobby OnReceivedLobby;

		public static Lobby Lobby;

		private static HashSet<ulong> Handshakes;

		static Manager()
		{
			MessageTypes = new Dictionary<string, (Type, bool, bool)>();
			Listeners = new Dictionary<string, List<(object, Action<INamedMessage>)>>();
			Handshakes = new HashSet<ulong>();
			Type[] types = typeof(Manager).Assembly.GetTypes();
			for (int i = 0; i < types.Length; i++)
			{
				if (typeof(INamedMessage).IsAssignableFrom(types[i]))
				{
					Message customAttribute = types[i].GetCustomAttribute<Message>();
					if (customAttribute != null)
					{
						MessageTypes.Add(customAttribute.Name, (types[i], customAttribute.ServerOnly, customAttribute.IsRelay));
					}
				}
			}
		}

		public static void Initialize()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				throw new Exception("NetworkManager is not initialized yet!");
			}
			Plugin.Log.LogMessage((object)"Initialize NetworkManager...");
			singleton.OnClientStarted += NetworkManager_OnClientStarted;
			singleton.OnClientStopped += NetworkManager_OnClientStopped;
			singleton.OnServerStarted += NetworkManager_OnServerStarted;
			singleton.OnServerStopped += NetworkManager_OnServerStopped;
		}

		public static void NetworkManager_OnClientConnectedCallback(ulong obj)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!singleton.IsServer)
			{
				Plugin.Log.LogMessage((object)"Client connected!");
			}
		}

		private static void AddMessageHandlers()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			Plugin.Log.LogMessage((object)"Adding message handlers.");
			NetworkManager singleton = NetworkManager.Singleton;
			foreach (KeyValuePair<string, (Type, bool, bool)> messageType in MessageTypes)
			{
				string name = messageType.Key;
				if (messageType.Value.Item3 && singleton.IsServer)
				{
					Plugin.Log.LogMessage((object)("AdvancedCompanyMod_" + name + "Relay"));
					singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_" + name + "Relay");
					singleton.CustomMessagingManager.RegisterNamedMessageHandler("AdvancedCompanyMod_" + name + "Relay", (HandleNamedMessageDelegate)delegate(ulong clientId, FastBufferReader reader)
					{
						//IL_0008: Unknown result type (might be due to invalid IL or missing references)
						RelayMessage(name, clientId, reader);
					});
				}
				else if (!messageType.Value.Item2 || singleton.IsServer)
				{
					Plugin.Log.LogMessage((object)("AdvancedCompanyMod_" + name));
					singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_" + name);
					singleton.CustomMessagingManager.RegisterNamedMessageHandler("AdvancedCompanyMod_" + name, (HandleNamedMessageDelegate)delegate(ulong clientId, FastBufferReader reader)
					{
						//IL_0008: Unknown result type (might be due to invalid IL or missing references)
						ReceiveMessage(name, clientId, reader);
					});
				}
			}
			if (!singleton.IsServer)
			{
				CustomMessagingManager customMessagingManager = singleton.CustomMessagingManager;
				object obj = <>O.<4>__ReceiveNewPlayer;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = ReceiveNewPlayer;
					<>O.<4>__ReceiveNewPlayer = val;
					obj = (object)val;
				}
				customMessagingManager.RegisterNamedMessageHandler("AdvancedCompanyMod_NewPlayer", (HandleNamedMessageDelegate)obj);
			}
			CustomMessagingManager customMessagingManager2 = singleton.CustomMessagingManager;
			object obj2 = <>O.<5>__ReceiveKick;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = ReceiveKick;
				<>O.<5>__ReceiveKick = val2;
				obj2 = (object)val2;
			}
			customMessagingManager2.RegisterNamedMessageHandler("AdvancedCompanyMod_Kick", (HandleNamedMessageDelegate)obj2);
		}

		private static void RemoveMessageHandlers()
		{
			Plugin.Log.LogMessage((object)"Removing message handlers.");
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton != (Object)null) || singleton.CustomMessagingManager == null)
			{
				return;
			}
			if (MessageTypes != null)
			{
				foreach (KeyValuePair<string, (Type, bool, bool)> messageType in MessageTypes)
				{
					string key = messageType.Key;
					singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_" + key + "Relay");
					singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_" + key);
				}
			}
			singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_ClientDisconnected");
			singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_Handshake");
			singleton.CustomMessagingManager.UnregisterNamedMessageHandler("AdvancedCompanyMod_Kick");
		}

		private static void NetworkManager_OnServerStarted()
		{
			Plugin.Log.LogMessage((object)"Server started!");
			AddMessageHandlers();
			NetworkManager singleton = NetworkManager.Singleton;
		}

		private static void NetworkManager_OnClientStarted()
		{
			if (!NetworkManager.Singleton.IsServer)
			{
				Plugin.Log.LogMessage((object)"Client started!");
				AddMessageHandlers();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void GameStartedPatch()
		{
			if (NetworkManager.Singleton.IsServer)
			{
				if (OnLobbyCreated != null)
				{
					OnLobbyCreated();
				}
			}
			else if (OnConnected != null)
			{
				OnConnected();
			}
		}

		private static void NetworkManager_OnServerStopped(bool obj)
		{
			Plugin.Log.LogMessage((object)"Server stopped!");
			RemoveMessageHandlers();
		}

		private static void NetworkManager_OnClientStopped(bool obj)
		{
			if (!NetworkManager.Singleton.IsServer)
			{
				Plugin.Log.LogMessage((object)"Client stopped!");
				RemoveMessageHandlers();
				if (OnDisconnected != null)
				{
					OnDisconnected();
				}
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Singleton_OnClientDisconnectCallback")]
		[HarmonyPrefix]
		private static void NetworkManager_OnClientDisconnectCallback(GameNetworkManager __instance, ulong clientId)
		{
			Plugin.Log.LogMessage((object)$"OnClientDisconnect for {clientId}");
			if (clientId == NetworkManager.Singleton.LocalClientId && __instance.localClientWaitingForApproval)
			{
				return;
			}
			try
			{
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while disconnecting client:");
				Plugin.Log.LogError((object)ex);
			}
		}

		private static void ReceiveKick(ulong clientId, FastBufferReader reader)
		{
			Plugin.Log.LogMessage((object)"Kick received.");
			string reason = default(string);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref reason, false);
			if (OnKicked != null)
			{
				OnKicked(reason);
			}
		}

		private static IEnumerator KickPlayer(ulong clientId, string kickReason)
		{
			yield return (object)new WaitForEndOfFrame();
			yield return (object)new WaitForEndOfFrame();
			NetworkManager networkManager = NetworkManager.Singleton;
			networkManager.DisconnectClient(clientId, kickReason);
		}

		private static IEnumerator WaitForHandshake(ulong clientId)
		{
			yield return (object)new WaitForSeconds(2f);
			if (Handshakes.Contains(clientId))
			{
				Handshakes.Remove(clientId);
				yield break;
			}
			NetworkManager networkManager = NetworkManager.Singleton;
			networkManager.DisconnectClient(clientId, "You are missing the AdvancedCompany mod!");
		}

		private static void ReceiveNewPlayer(ulong clientId, FastBufferReader reader)
		{
			//IL_0039: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.IsServer)
			{
				return;
			}
			Plugin.Log.LogInfo((object)"New player connected to lobby.");
			try
			{
				int playerNum = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref playerNum, default(ForPrimitives));
				Plugin.Log.LogInfo((object)("Player num: " + playerNum));
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(playerNum);
				player.ReadData(reader);
				Lobby.PlayerConnected(player, player.JoinedLate);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while receiving handshake!");
				Plugin.Log.LogError((object)ex);
			}
		}

		private static INamedMessage ReceiveMessage(string name, ulong clientId, FastBufferReader reader)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)$"Message received '{name}' from {clientId}.");
			NetworkManager singleton = NetworkManager.Singleton;
			INamedMessage namedMessage = (INamedMessage)Activator.CreateInstance(MessageTypes[name].Type);
			namedMessage.ReadData(reader);
			if (Listeners.ContainsKey(name))
			{
				for (int i = 0; i < Listeners[name].Count; i++)
				{
					Listeners[name][i].Item2(namedMessage);
				}
			}
			return namedMessage;
		}

		private static void RelayMessage(string name, ulong clientId, FastBufferReader reader)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)$"Relaying message '{name}' from {clientId}.");
			NetworkManager singleton = NetworkManager.Singleton;
			INamedMessage message = ReceiveMessage(name, clientId, reader);
			List<ulong> list = new List<ulong>(singleton.ConnectedClientsIds);
			list.Remove(0uL);
			list.Remove(clientId);
			Send(message, list);
		}

		public static void Send(INamedMessage message, ulong clientID = 0uL)
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			Message customAttribute = message.GetType().GetCustomAttribute<Message>();
			string name = customAttribute.Name;
			NetworkManager singleton = NetworkManager.Singleton;
			if (clientID == 0L && customAttribute.IsRelay && singleton.IsServer)
			{
				if (Listeners.ContainsKey(name))
				{
					for (int i = 0; i < Listeners[name].Count; i++)
					{
						Listeners[name][i].Item2(message);
					}
				}
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(1024, (Allocator)2, int.MaxValue);
				try
				{
					message.WriteData(val);
					string text = "AdvancedCompanyMod_" + name;
					List<ulong> list = new List<ulong>(NetworkManager.Singleton.ConnectedClientsIds);
					list.Remove(0uL);
					singleton.CustomMessagingManager.SendNamedMessage(text, (IReadOnlyList<ulong>)list, val, (NetworkDelivery)4);
					return;
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
			}
			if (customAttribute.IsRelay && Listeners.ContainsKey(name))
			{
				for (int j = 0; j < Listeners[name].Count; j++)
				{
					Listeners[name][j].Item2(message);
				}
			}
			FastBufferWriter val2 = default(FastBufferWriter);
			((FastBufferWriter)(ref val2))..ctor(1024, (Allocator)2, int.MaxValue);
			try
			{
				message.WriteData(val2);
				string text2 = "AdvancedCompanyMod_" + name;
				if (customAttribute.IsRelay)
				{
					text2 += "Relay";
				}
				singleton.CustomMessagingManager.SendNamedMessage(text2, clientID, val2, (NetworkDelivery)4);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
			}
		}

		public static void Send(INamedMessage message, IReadOnlyList<ulong> recipients)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			if (!singleton.IsServer)
			{
				throw new InvalidOperationException("Only server can send messages to clients.");
			}
			Message customAttribute = message.GetType().GetCustomAttribute<Message>();
			string name = customAttribute.Name;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(1024, (Allocator)2, int.MaxValue);
			try
			{
				message.WriteData(val);
				singleton.CustomMessagingManager.SendNamedMessage("AdvancedCompanyMod_" + name, recipients, val, (NetworkDelivery)4);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void SendToAll(INamedMessage message)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			if (!singleton.IsServer)
			{
				throw new InvalidOperationException("Only server can send messages to clients.");
			}
			Message customAttribute = message.GetType().GetCustomAttribute<Message>();
			string name = customAttribute.Name;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(1024, (Allocator)2, int.MaxValue);
			try
			{
				message.WriteData(val);
				List<ulong> list = new List<ulong>(NetworkManager.Singleton.ConnectedClientsIds);
				list.Remove(0uL);
				singleton.CustomMessagingManager.SendNamedMessage("AdvancedCompanyMod_" + name, (IReadOnlyList<ulong>)list, val, (NetworkDelivery)4);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void AddListener<T>(Action<T> listener) where T : INamedMessage
		{
			string name = typeof(T).GetCustomAttribute<Message>().Name;
			if (!Listeners.ContainsKey(name))
			{
				Listeners.Add(name, new List<(object, Action<INamedMessage>)>());
			}
			Listeners[name].Add((listener, delegate(INamedMessage msg)
			{
				listener((T)msg);
			}));
		}

		public static bool RemoveListener<T>(Action<T> listener) where T : INamedMessage
		{
			string name = typeof(T).GetCustomAttribute<Message>().Name;
			if (Listeners.ContainsKey(name))
			{
				for (int i = 0; i < Listeners[name].Count; i++)
				{
					if (Listeners[name][i].Item1 == listener)
					{
						Listeners[name].RemoveAt(i);
						return true;
					}
				}
			}
			return false;
		}

		public static void RemoveAllListeners<T>()
		{
			string name = typeof(T).GetCustomAttribute<Message>().Name;
			Listeners.Remove(name);
		}
	}
	internal class Message : Attribute
	{
		internal string Name;

		internal bool ServerOnly;

		internal bool IsRelay;

		internal Message(string name, bool serverOnly = false, bool isRelay = false)
		{
			Name = name;
			ServerOnly = serverOnly;
			IsRelay = isRelay;
		}
	}
}
namespace AdvancedCompany.Network.Sync
{
	internal class AnimatedObjectTriggerSynchronization : ISyncHandler, INetworkObjectsPlaced
	{
		public ulong[] ObjectNetworkIDs;

		public ushort[] ObjectBehaviourIDs;

		public bool[] BoolValue;

		public string GetIdentifier()
		{
			return "AdvCmpny.AnimatedObjectTrigger";
		}

		public void NetworkObjectsPlaced()
		{
			if (ObjectNetworkIDs == null)
			{
				return;
			}
			for (int i = 0; i < ObjectNetworkIDs.Length; i++)
			{
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(ObjectNetworkIDs[i]))
				{
					NetworkObject val = NetworkManager.Singleton.SpawnManager.SpawnedObjects[ObjectNetworkIDs[i]];
					NetworkBehaviour networkBehaviourAtOrderIndex = val.GetNetworkBehaviourAtOrderIndex(ObjectBehaviourIDs[i]);
					AnimatedObjectTrigger val2 = (AnimatedObjectTrigger)(object)((networkBehaviourAtOrderIndex is AnimatedObjectTrigger) ? networkBehaviourAtOrderIndex : null);
					if (val2 != null)
					{
						val2.boolValue = BoolValue[i];
						if ((Object)(object)val2.triggerAnimator != (Object)null)
						{
							val2.triggerAnimator.SetBool(val2.animationString, BoolValue[i]);
						}
						if ((Object)(object)val2.triggerAnimatorB != (Object)null)
						{
							val2.triggerAnimatorB.SetBool("on", BoolValue[i]);
						}
					}
					else
					{
						Plugin.Log.LogWarning((object)("Network object with ID " + ObjectNetworkIDs[i] + " had no trigger with ID " + ObjectBehaviourIDs[i]));
					}
				}
				else
				{
					Plugin.Log.LogWarning((object)("Network object with ID " + ObjectNetworkIDs[i] + " was not found!"));
				}
			}
		}

		public void ReadDataFromClientBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
		}

		public void ReadDataFromJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			ObjectNetworkIDs = new ulong[num];
			ObjectBehaviourIDs = new ushort[num];
			BoolValue = new bool[num];
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref ObjectNetworkIDs[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<ushort>(ref ObjectBehaviourIDs[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref BoolValue[i], default(ForPrimitives));
			}
		}

		public void WriteDataToHostBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
		}

		public void WriteDataToPlayerJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			AnimatedObjectTrigger[] array = Object.FindObjectsOfType<AnimatedObjectTrigger>();
			List<ulong> list = new List<ulong>();
			List<ushort> list2 = new List<ushort>();
			List<bool> list3 = new List<bool>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].isBool)
				{
					list.Add(((NetworkBehaviour)array[i]).NetworkObjectId);
					list2.Add(((NetworkBehaviour)array[i]).NetworkBehaviourId);
					list3.Add(array[i].boolValue);
				}
			}
			int count = list.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			for (int j = 0; j < list.Count; j++)
			{
				ulong num = list[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
				ushort num2 = list2[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<ushort>(ref num2, default(ForPrimitives));
				bool flag = list3[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			}
		}
	}
	internal class DoorLockSynchronization : ISyncHandler, INetworkObjectsPlaced
	{
		public ulong[] DoorNetworkIDs;

		public bool[] IsDoorOpened;

		public bool[] IsLocked;

		public float[] LockPickTimeLeft;

		public float[] EnemyDoorMeter;

		public string GetIdentifier()
		{
			return "AdvCmpny.DoorLocks";
		}

		public void NetworkObjectsPlaced()
		{
			if (DoorNetworkIDs == null)
			{
				return;
			}
			for (int i = 0; i < DoorNetworkIDs.Length; i++)
			{
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(DoorNetworkIDs[i]))
				{
					NetworkObject val = NetworkManager.Singleton.SpawnManager.SpawnedObjects[DoorNetworkIDs[i]];
					DoorLock componentInChildren = ((Component)val).gameObject.GetComponentInChildren<DoorLock>();
					componentInChildren.isDoorOpened = IsDoorOpened[i];
					componentInChildren.isLocked = IsLocked[i];
					componentInChildren.lockPickTimeLeft = LockPickTimeLeft[i];
					componentInChildren.enemyDoorMeter = EnemyDoorMeter[i];
				}
				else
				{
					Plugin.Log.LogWarning((object)("Network object with ID " + DoorNetworkIDs[i] + " was not found!"));
				}
			}
		}

		public void ReadDataFromClientBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
		}

		public void ReadDataFromJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			DoorNetworkIDs = new ulong[num];
			IsDoorOpened = new bool[num];
			IsLocked = new bool[num];
			LockPickTimeLeft = new float[num];
			EnemyDoorMeter = new float[num];
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref DoorNetworkIDs[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsDoorOpened[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsLocked[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref LockPickTimeLeft[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref EnemyDoorMeter[i], default(ForPrimitives));
			}
		}

		public void WriteDataToHostBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
		}

		public void WriteDataToPlayerJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			DoorLock[] array = Object.FindObjectsOfType<DoorLock>();
			List<ulong> list = new List<ulong>();
			List<bool> list2 = new List<bool>();
			List<bool> list3 = new List<bool>();
			List<float> list4 = new List<float>();
			List<float> list5 = new List<float>();
			for (int i = 0; i < array.Length; i++)
			{
				list.Add(((NetworkBehaviour)array[i]).NetworkObjectId);
				list2.Add(array[i].isDoorOpened);
				list3.Add(array[i].isLocked);
				list4.Add(array[i].lockPickTimeLeft);
				list5.Add(array[i].enemyDoorMeter);
			}
			int count = list.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			for (int j = 0; j < list.Count; j++)
			{
				ulong num = list[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
				bool flag = list2[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				flag = list3[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				float num2 = list4[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref num2, default(ForPrimitives));
				num2 = list5[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref num2, default(ForPrimitives));
			}
		}
	}
	internal class LobbyDataSynchronization : ISyncHandler, IConnectClientToPlayerObject
	{
		public AdvancedCompany.Game.Player Player;

		public Dictionary<string, string> Mods;

		public int PlayerNum;

		public int CurrentLevelID;

		public int CurrentSeed;

		public LevelWeatherType CurrentWeather;

		public int[] DeadPlayers;

		public bool OnMoon;

		public bool GameHasStarted;

		public void ConnectClientToPlayerObject(PlayerControllerB player)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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)
			StartOfRound instance = StartOfRound.Instance;
			RoundManager instance2 = RoundManager.Instance;
			GameNetworkManager instance3 = GameNetworkManager.Instance;
			if (!((Object)(object)instance != (Object)null) || !((Object)(object)instance2 != (Object)null) || !((Object)(object)instance3 != (Object)null))
			{
				return;
			}
			instance.currentLevel = instance.levels[CurrentLevelID];
			instance.randomMapSeed = CurrentSeed;
			instance.SetPlanetsWeather(0);
			instance.currentLevel.currentWeather = CurrentWeather;
			instance.currentLevel.overrideWeather = true;
			instance.currentLevel.overrideWeatherType = CurrentWeather;
			instance2.currentLevel = instance.currentLevel;
			instance3.gameHasStarted = GameHasStarted;
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = instance.allPlayerScripts[i];
				bool flag = false;
				for (int j = 0; j < DeadPlayers.Length; j++)
				{
					if (DeadPlayers[j] == (int)val.playerClientId)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					Plugin.Log.LogMessage((object)("Player " + val.playerClientId + " is dead!"));
					val.bleedingHeavily = false;
					val.statusEffectAudio.Stop();
					val.isPlayerDead = true;
					val.snapToServerPosition = false;
					val.isUnderwater = false;
					val.isHoldingInteract = false;
					val.isPlayerControlled = false;
					val.currentlyHeldObject = null;
					SoundManager.Instance.playerVoicePitchTargets[i] = 1f;
					SoundManager.Instance.playerVoicePitchLerpSpeed[i] = 3f;
					val.DisablePlayerModel(((Component)player).gameObject, false, false);
				}
			}
			if (OnMoon)
			{
				instance.inShipPhase = false;
				((MonoBehaviour)instance2).StartCoroutine(LoadLevel(instance, instance2));
			}
			else
			{
				LobbySizePatches.Handshake = null;
			}
		}

		private static IEnumerator LoadLevel(StartOfRound startOfRound, RoundManager roundManager)
		{
			yield return (object)new WaitForSeconds(0.1f);
			((NetworkBehaviour)roundManager).__rpc_exec_stage = (__RpcExecStage)2;
			roundManager.GenerateNewLevelClientRpc(startOfRound.randomMapSeed, startOfRound.currentLevelID);
			((NetworkBehaviour)roundManager).__rpc_exec_stage = (__RpcExecStage)0;
		}

		public string GetIdentifier()
		{
			return "AdvCmpny.Lobby";
		}

		public void ReadDataFromClientBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_0018: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
			Mods = new Dictionary<string, string>();
			Dictionary<uint, string> networkPrefabIdentifiers = GetNetworkPrefabIdentifiers();
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			Dictionary<uint, string> dictionary = new Dictionary<uint, string>();
			uint key = default(uint);
			string text = default(string);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<uint>(ref key, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, true);
				dictionary.Add(key, text);
				Plugin.Log.LogDebug((object)("Received network prefab: " + key + ":" + text));
			}
			Dictionary<uint, string> dictionary2 = new Dictionary<uint, string>();
			Dictionary<uint, string> dictionary3 = new Dictionary<uint, string>();
			Dictionary<uint, string> dictionary4 = new Dictionary<uint, string>();
			foreach (KeyValuePair<uint, string> item in dictionary)
			{
				if (!networkPrefabIdentifiers.ContainsKey(item.Key))
				{
					dictionary3.Add(item.Key, item.Value);
				}
			}
			foreach (KeyValuePair<uint, string> item2 in networkPrefabIdentifiers)
			{
				if (dictionary.ContainsKey(item2.Key))
				{
					if (dictionary[item2.Key] != networkPrefabIdentifiers[item2.Key])
					{
						dictionary4.Add(item2.Key, dictionary[item2.Key] + "|" + networkPrefabIdentifiers[item2.Key]);
					}
				}
				else
				{
					dictionary2.Add(item2.Key, item2.Value);
				}
			}
			Dictionary<string, int> dictionary5 = new Dictionary<string, int>();
			Dictionary<string, int> dictionary6 = new Dictionary<string, int>();
			foreach (KeyValuePair<uint, string> item3 in dictionary4)
			{
				Plugin.Log.LogWarning((object)("Mismatched network identifier: " + item3.Key + ":" + item3.Value));
			}
			foreach (KeyValuePair<uint, string> item4 in dictionary3)
			{
				Plugin.Log.LogWarning((object)("Client was missing network identifier: " + item4.Key + ":" + item4.Value));
				string[] array = item4.Value.Split(":");
				if (array.Length == 2)
				{
					if (!dictionary6.ContainsKey(array[1]))
					{
						dictionary6.Add(array[1], 1);
					}
					else
					{
						dictionary6[array[1]]++;
					}
				}
			}
			foreach (KeyValuePair<uint, string> item5 in dictionary2)
			{
				Plugin.Log.LogWarning((object)("Host was missing network identifier: " + item5.Key + ":" + item5.Value));
				string[] array2 = item5.Value.Split(":");
				if (array2.Length == 2)
				{
					if (!dictionary5.ContainsKey(array2[1]))
					{
						dictionary5.Add(array2[1], 1);
					}
					else
					{
						dictionary5[array2[1]]++;
					}
				}
			}
			if (dictionary3.Count > 0 || dictionary2.Count > 0)
			{
				string text2 = "";
				foreach (KeyValuePair<string, int> item6 in dictionary6)
				{
					text2 = text2 + item6.Key + ": " + item6.Value + " prefabs\n";
				}
				string text3 = "";
				foreach (KeyValuePair<string, int> item7 in dictionary5)
				{
					text3 = text3 + item7.Key + ": " + item7.Value + " prefabs\n";
				}
				sync.SetError("NetworkConfig mismatch.\n" + ((text2 != "") ? ("Missing:\n" + text2) : "") + ((text3 != "") ? ("Host doesn't support:\n" + text3) : ""));
				return;
			}
			int num2 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
			string key2 = default(string);
			string value = default(string);
			for (int j = 0; j < num2; j++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref key2, true);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref value, true);
				Mods.Add(key2, value);
			}
			Plugin.Log.LogDebug((object)("Mods installed: " + string.Join(", ", Mods.Keys)));
			Player = new AdvancedCompany.Game.Player();
			Player.ClientID = sync.ClientId;
			Player.ReadData(reader);
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, string> requiredMod in Mod.RequiredMods)
			{
				if (!Mods.ContainsKey(requiredMod.Key))
				{
					list.Add(requiredMod.Key + " (" + requiredMod.Value + ")");
				}
				else if (Mods[requiredMod.Key] != requiredMod.Value)
				{
					list2.Add(requiredMod.Key + " (" + requiredMod.Value + ")");
				}
			}
			List<string> list3 = new List<string>();
			foreach (KeyValuePair<string, string> mod in Mods)
			{
				if (!Mod.RequiredMods.ContainsKey(mod.Key))
				{
					list3.Add(mod.Key + " (" + mod.Value + ")");
				}
			}
			if (list.Count > 0 || list3.Count > 0 || list2.Count > 0)
			{
				string text4 = (((list.Count > 0) ? ("Missing mods: " + string.Join(", ", list)) : "") + ((list3.Count > 0) ? (" Unsupported mods: " + string.Join(", ", list3)) : "") + ((list3.Count > 0) ? (" Mismatched versions: " + string.Join(", ", list2)) : "")).Trim();
				sync.SetError(text4);
				Plugin.Log.LogWarning((object)("Client has mismatching mods: " + text4));
				return;
			}
			if (!NetworkManager.Singleton.NetworkConfig.CompareConfig(sync.ConfigHash))
			{
				sync.SetError("Unity NetworkConfig mismatch.");
				Plugin.Log.LogWarning((object)"NewtorkConfig mismatch.");
				return;
			}
			if (Player == null)
			{
				sync.SetError("There was a problem with parsing a handshake from connecting client. Player was null.");
				return;
			}
			bool joinedLate = false;
			StartOfRound instance = StartOfRound.Instance;
			if (!instance.inShipPhase)
			{
				joinedLate = true;
				Plugin.Log.LogMessage((object)("We are not in ship phase. Adding " + Player.PlayerNum + " to late joiners."));
			}
			Player.JoinedLate = joinedLate;
			Player.LoadServer(GameNetworkManager.Instance.currentSaveFileName);
			bool flag = Player.RemainingXP < 0;
			if (!flag)
			{
				foreach (Perk item8 in Perk.PerksByType(Perk.Type.PLAYER))
				{
					if (Player.Levels.ContainsKey(item8.ID) && Player.Levels[item8.ID] > 0 && (!item8.IsActive || Player.Levels[item8.ID] > item8.Levels))
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				Player.Levels = new Dictionary<string, int>();
			}
		}

		public void ReadDataFromJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ServerConfiguration.Instance.ReadData(reader);
				ServerConfiguration.Instance.WasLoaded();
				Manager.Lobby = new Lobby();
				Manager.Lobby.ReadData(reader);
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				Plugin.Log.LogMessage((object)("Server sent our player ID: " + num));
				Lobby.LocalPlayerNum = num;
				Player = Manager.Lobby.Player(num);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref CurrentLevelID, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref CurrentSeed, default(ForPrimitives));
				string value = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref value, true);
				Enum.TryParse<LevelWeatherType>(value, out CurrentWeather);
				int num2 = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				DeadPlayers = new int[num2];
				int num3 = default(int);
				for (int i = 0; i < DeadPlayers.Length; i++)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num3, default(ForPrimitives));
					DeadPlayers[i] = num3;
				}
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref OnMoon, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref GameHasStarted, default(ForPrimitives));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while reading lobby handshake:");
				Plugin.Log.LogError((object)ex);
				sync.Error = "Error while reading lobby handshake";
			}
		}

		private static Dictionary<uint, string> GetNetworkPrefabIdentifiers()
		{
			Dictionary<uint, string> dictionary = new Dictionary<uint, string>();
			foreach (KeyValuePair<uint, NetworkPrefab> item in NetworkManager.Singleton.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.OrderBy((KeyValuePair<uint, NetworkPrefab> x) => x.Key))
			{
				string text = null;
				string value = "";
				if ((Object)(object)item.Value.Prefab != (Object)null)
				{
					value = ((Object)item.Value.Prefab).name;
					Component[] components = item.Value.Prefab.GetComponents<Component>();
					Component[] array = components;
					foreach (Component val in array)
					{
						string name = ((object)val).GetType().Assembly.GetName().Name;
						if (name.StartsWith("Assembly") || name.StartsWith("Unity"))
						{
							continue;
						}
						foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
						{
							if (((object)pluginInfo.Value.Instance).GetType().Assembly == ((object)val).GetType().Assembly)
							{
								text = pluginInfo.Value.Metadata.Name;
								break;
							}
						}
						if (text == null)
						{
							text = name;
						}
					}
					value = value + ":" + ((text == null) ? "Vanilla" : text);
				}
				dictionary.Add(item.Key, value);
			}
			return dictionary;
		}

		public void WriteDataToHostBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_007c: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<uint, string> networkPrefabIdentifiers = GetNetworkPrefabIdentifiers();
			int count = networkPrefabIdentifiers.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (KeyValuePair<uint, string> item in networkPrefabIdentifiers)
			{
				Plugin.Log.LogDebug((object)("Writing network prefab: " + item.Key + ":" + item.Value));
				uint key = item.Key;
				((FastBufferWriter)(ref writer)).WriteValueSafe<uint>(ref key, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe(item.Value, true);
			}
			count = Mod.RequiredMods.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (KeyValuePair<string, string> requiredMod in Mod.RequiredMods)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(requiredMod.Key, true);
				((FastBufferWriter)(ref writer)).WriteValueSafe(requiredMod.Value, true);
			}
			AdvancedCompany.Game.Player player = new AdvancedCompany.Game.Player();
			player.LoadLocal();
			player.WriteData(writer);
		}

		public void WriteDataToPlayerJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SteamNetworkingUtils.SendBufferSize = 2097152;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while increasing send buffer:");
				Plugin.Log.LogError((object)ex);
			}
			int num = 999;
			for (int i = 1; i < ServerConfiguration.Instance.Lobby.LobbySize; i++)
			{
				if (!Manager.Lobby.ConnectedPlayers.ContainsKey(i))
				{
					num = i;
					break;
				}
			}
			if (num != 999)
			{
				Plugin.Log.LogInfo((object)("Next free spot: " + num));
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(num);
				player.CopyFrom(Player);
				player.PlayerNum = num;
				PlayerNum = player.PlayerNum;
				StartOfRound instance = StartOfRound.Instance;
				GameNetworkManager instance2 = GameNetworkManager.Instance;
				Manager.Lobby.PlayerConnected(player, player.JoinedLate);
				Plugin.Log.LogInfo((object)"Syncing new player to other players...");
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(1024, (Allocator)2, 65536);
				int playerNum;
				try
				{
					playerNum = player.PlayerNum;
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref playerNum, default(ForPrimitives));
					player.WriteData(val);
					List<ulong> list = new List<ulong>(NetworkManager.Singleton.ConnectedClientsIds);
					list.Remove(NetworkManager.Singleton.LocalClientId);
					list.Remove(sync.ClientId);
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("AdvancedCompanyMod_NewPlayer", (IReadOnlyList<ulong>)list, val, (NetworkDelivery)2);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
				ServerConfiguration.Instance.WriteData(writer);
				Manager.Lobby.WriteData(writer);
				playerNum = player.PlayerNum;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref playerNum, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref instance.currentLevelID, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref instance.randomMapSeed, default(ForPrimitives));
				string name = Enum.GetName(typeof(LevelWeatherType), instance.currentLevel.currentWeather);
				((FastBufferWriter)(ref writer)).WriteValueSafe(name, true);
				List<int> list2 = new List<int>();
				for (int j = 0; j < instance.allPlayerScripts.Length; j++)
				{
					PlayerControllerB val2 = instance.allPlayerScripts[j];
					if (val2.isPlayerDead)
					{
						list2.Add((int)val2.playerClientId);
					}
				}
				playerNum = list2.Count;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref playerNum, default(ForPrimitives));
				for (int k = 0; k < list2.Count; k++)
				{
					playerNum = list2[k];
					((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref playerNum, default(ForPrimitives));
				}
				bool flag = !instance.inShipPhase;
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref instance2.gameHasStarted, default(ForPrimitives));
			}
			else
			{
				sync.SetError("Lobby full when it shouldn't be!?");
			}
		}
	}
	internal class OtherSynchronization : ISyncHandler, INetworkObjectsPlaced, ILevelLoaded
	{
		public bool ShipLightsOn;

		public int LivingPlayers;

		public int DaysSpent;

		public int AllStepsTaken;

		public int Deaths;

		public int ScrapValueCollected;

		public int[] DamageTaken;

		public int[] StepsTaken;

		public int[] Jumps;

		public int[] Profitable;

		public int[] TurnAmount;

		public List<string>[] PlayerNotes;

		public float TotalScrapValueInLevel;

		public int ScrapCollectedInLevel;

		public int ValueOfFoundScrapItems;

		public bool PowerOffPermanently;

		public bool BreakerBoxIsPowerOn;

		public int BreakerBoxLeversSwitchedOff;

		public string GetIdentifier()
		{
			return "AdvCmpny.Other";
		}

		public void NetworkObjectsPlaced()
		{
			ShipLights val = Object.FindObjectOfType<ShipLights>();
			val.SetShipLightsOnLocalClientOnly(ShipLightsOn);
			StartOfRound.Instance.gameStats.daysSpent = DaysSpent;
			StartOfRound.Instance.gameStats.allStepsTaken = AllStepsTaken;
			StartOfRound.Instance.gameStats.deaths = Deaths;
			StartOfRound.Instance.gameStats.scrapValueCollected = ScrapValueCollected;
			for (int i = 0; i < StartOfRound.Instance.gameStats.allPlayerStats.Length; i++)
			{
				StartOfRound.Instance.gameStats.allPlayerStats[i].damageTaken = DamageTaken[i];
				StartOfRound.Instance.gameStats.allPlayerStats[i].stepsTaken = StepsTaken[i];
				StartOfRound.Instance.gameStats.allPlayerStats[i].jumps = Jumps[i];
				StartOfRound.Instance.gameStats.allPlayerStats[i].profitable = Profitable[i];
				StartOfRound.Instance.gameStats.allPlayerStats[i].turnAmount = TurnAmount[i];
				StartOfRound.Instance.gameStats.allPlayerStats[i].playerNotes = PlayerNotes[i];
			}
		}

		public void LevelLoaded()
		{
			StartOfRound.Instance.livingPlayers = LivingPlayers + 1;
			RoundManager.Instance.totalScrapValueInLevel = TotalScrapValueInLevel;
			RoundManager.Instance.scrapCollectedInLevel = ScrapCollectedInLevel;
			RoundManager.Instance.valueOfFoundScrapItems = ValueOfFoundScrapItems;
			RoundManager.Instance.powerOffPermanently = PowerOffPermanently;
			BreakerBox val = Object.FindObjectOfType<BreakerBox>();
			if ((Object)(object)val != (Object)null)
			{
				val.isPowerOn = BreakerBoxIsPowerOn;
				val.leversSwitchedOff = BreakerBoxLeversSwitchedOff;
				RoundManager.Instance.SwitchPower(!RoundManager.Instance.powerOffPermanently && val.isPowerOn);
			}
		}

		public void ReadDataFromClientBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
		}

		public void ReadDataFromJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ShipLightsOn, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref LivingPlayers, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref DaysSpent, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref AllStepsTaken, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Deaths, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ScrapValueCollected, default(ForPrimitives));
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			DamageTaken = new int[num];
			StepsTaken = new int[num];
			Jumps = new int[num];
			Profitable = new int[num];
			TurnAmount = new int[num];
			PlayerNotes = new List<string>[num];
			int num2 = default(int);
			string item = default(string);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref DamageTaken[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref StepsTaken[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Jumps[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Profitable[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref TurnAmount[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				PlayerNotes[i] = new List<string>();
				for (int j = 0; j < num2; j++)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref item, true);
					PlayerNotes[i].Add(item);
				}
			}
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TotalScrapValueInLevel, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ScrapCollectedInLevel, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ValueOfFoundScrapItems, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref PowerOffPermanently, default(ForPrimitives));
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref BreakerBoxIsPowerOn, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref BreakerBoxLeversSwitchedOff, default(ForPrimitives));
			}
		}

		public void WriteDataToHostBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
		}

		public void WriteDataToPlayerJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			ShipLights val = Object.FindObjectOfType<ShipLights>();
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref val.areLightsOn, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.livingPlayers, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.daysSpent, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allStepsTaken, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.deaths, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.scrapValueCollected, default(ForPrimitives));
			int num = StartOfRound.Instance.gameStats.allPlayerStats.Length;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			for (int i = 0; i < StartOfRound.Instance.gameStats.allPlayerStats.Length; i++)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allPlayerStats[i].damageTaken, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allPlayerStats[i].stepsTaken, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allPlayerStats[i].jumps, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allPlayerStats[i].profitable, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref StartOfRound.Instance.gameStats.allPlayerStats[i].turnAmount, default(ForPrimitives));
				num = StartOfRound.Instance.gameStats.allPlayerStats[i].playerNotes.Count;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				for (int j = 0; j < StartOfRound.Instance.gameStats.allPlayerStats[i].playerNotes.Count; j++)
				{
					((FastBufferWriter)(ref writer)).WriteValueSafe(StartOfRound.Instance.gameStats.allPlayerStats[i].playerNotes[j], true);
				}
			}
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref RoundManager.Instance.totalScrapValueInLevel, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref RoundManager.Instance.scrapCollectedInLevel, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref RoundManager.Instance.valueOfFoundScrapItems, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref RoundManager.Instance.powerOffPermanently, default(ForPrimitives));
			BreakerBox val2 = Object.FindObjectOfType<BreakerBox>();
			if ((Object)(object)val2 != (Object)null)
			{
				bool flag = true;
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref val2.isPowerOn, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref val2.leversSwitchedOff, default(ForPrimitives));
			}
			else
			{
				bool flag = false;
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			}
		}
	}
	internal class RedLocustBeesSynchronization : ISyncHandler, INetworkObjectsPlaced
	{
		public ulong[] BeesNetworkIDs;

		public ulong[] HivesNetworkIDs;

		public string GetIdentifier()
		{
			return "AdvCmpny.RedLocust";
		}

		public void NetworkObjectsPlaced()
		{
			if (BeesNetworkIDs == null)
			{
				return;
			}
			for (int i = 0; i < BeesNetworkIDs.Length; i++)
			{
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(BeesNetworkIDs[i]) && NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(HivesNetworkIDs[i]))
				{
					NetworkObject val = NetworkManager.Singleton.SpawnManager.SpawnedObjects[BeesNetworkIDs[i]];
					NetworkObject val2 = NetworkManager.Singleton.SpawnManager.SpawnedObjects[HivesNetworkIDs[i]];
					RedLocustBees component = ((Component)val).GetComponent<RedLocustBees>();
					component.hasSpawnedHive = true;
					component.hive = ((Component)val2).GetComponent<GrabbableObject>();
				}
				else
				{
					Plugin.Log.LogWarning((object)("Network object with ID " + BeesNetworkIDs[i] + " was not found!"));
				}
			}
		}

		public void ReadDataFromClientBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
		}

		public void ReadDataFromJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			BeesNetworkIDs = new ulong[num];
			HivesNetworkIDs = new ulong[num];
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref BeesNetworkIDs[i], default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref HivesNetworkIDs[i], default(ForPrimitives));
			}
		}

		public void WriteDataToHostBeforeJoining(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
		}

		public void WriteDataToPlayerJoiningLobby(AdvancedCompany.Lib.Sync sync, FastBufferWriter writer)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			RedLocustBees[] array = Object.FindObjectsOfType<RedLocustBees>();
			List<ulong> list = new List<ulong>();
			List<ulong> list2 = new List<ulong>();
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i].hive != (Object)null)
				{
					NetworkObject component = ((Component)array[i]).GetComponent<NetworkObject>();
					list.Add(component.NetworkObjectId);
					NetworkObject component2 = ((Component)array[i].hive).GetComponent<NetworkObject>();
					list2.Add(component2.NetworkObjectId);
				}
			}
			int count = list.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			for (int j = 0; j < list.Count; j++)
			{
				ulong num = list[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
				num = list2[j];
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
			}
		}
	}
}
namespace AdvancedCompany.Network.Sync.Items
{
	internal class BulletProofVestSynchronizationHandler : IItemSynchronisationHandler<BulletProofVest>
	{
		public int Damage;

		public override void Apply(BulletProofVest item)
		{
			item.Damage = Damage;
		}

		public override void Read(BulletProofVest item)
		{
			Damage = item.Damage;
		}

		public override void Read(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Damage, default(ForPrimitives));
		}

		public override void Write(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Damage, default(ForPrimitives));
		}
	}
	internal class GrabbableObjectSynchronizationHandler : IItemSynchronisationHandler<GrabbableObject>
	{
		public bool HasBattery = false;

		public float BatteryCharge = 0f;

		public Vector3 StartFallingPosition;

		public int FloorYRot;

		public float FallTime;

		public bool HasHitGround;

		public int ScrapValue;

		public bool ItemUsedUp;

		public bool IsPocketed;

		public bool IsInElevator;

		public bool IsBeingUsed;

		public bool IsInShipRoom;

		public bool IsInFactory;

		public bool Deactivated;

		public bool HasBeenHeld;

		public bool ScrapPersistedThroughRounds;

		public bool ReachedFloorTarget;

		public ulong ParentObject;

		public override void Apply(GrabbableObject item)
		{
			//IL_000f: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			item.hasHitGround = HasHitGround;
			item.startFallingPosition = StartFallingPosition;
			item.floorYRot = FloorYRot;
			item.fallTime = FallTime;
			item.scrapValue = ScrapValue;
			item.itemUsedUp = ItemUsedUp;
			item.isPocketed = IsPocketed;
			item.isInElevator = IsInElevator;
			item.isBeingUsed = IsBeingUsed;
			item.isInShipRoom = IsInShipRoom;
			item.isInFactory = IsInFactory;
			item.deactivated = Deactivated;
			item.hasBeenHeld = HasBeenHeld;
			item.scrapPersistedThroughRounds = ScrapPersistedThroughRounds;
			item.reachedFloorTarget = ReachedFloorTarget;
			if (ParentObject != 0 && NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(ParentObject))
			{
				item.parentObject = ((Component)NetworkManager.Singleton.SpawnManager.SpawnedObjects[ParentObject]).transform;
			}
			if (HasBattery)
			{
				if (item.insertedBattery == null)
				{
					item.insertedBattery = new Battery(BatteryCharge == 0f, BatteryCharge);
				}
				else
				{
					item.insertedBattery.charge = BatteryCharge;
				}
			}
		}

		public override void Read(GrabbableObject item)
		{
			//IL_0003: 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)
			StartFallingPosition = item.startFallingPosition;
			FloorYRot = item.floorYRot;
			FallTime = item.fallTime;
			HasHitGround = item.hasHitGround;
			ScrapValue = item.scrapValue;
			ItemUsedUp = item.itemUsedUp;
			IsPocketed = item.isPocketed;
			IsInElevator = item.isInElevator;
			IsBeingUsed = item.isBeingUsed;
			IsInShipRoom = item.isInShipRoom;
			IsInFactory = item.isInFactory;
			Deactivated = item.deactivated;
			ScrapPersistedThroughRounds = item.scrapPersistedThroughRounds;
			ReachedFloorTarget = item.reachedFloorTarget;
			if ((Object)(object)item.parentObject != (Object)null)
			{
				NetworkObject component = ((Component)item).GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null)
				{
					ParentObject = component.NetworkObjectId;
				}
			}
			HasBattery = item.insertedBattery != null;
			if (item.insertedBattery != null)
			{
				BatteryCharge = item.insertedBattery.charge;
			}
		}

		public override void Read(FastBufferReader reader)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0092: 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_00a9: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe(ref StartFallingPosition);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref FloorYRot, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref FallTime, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref HasHitGround, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ScrapValue, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ItemUsedUp, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsPocketed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsInElevator, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsBeingUsed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsInShipRoom, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsInFactory, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref Deactivated, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref ParentObject, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref HasBattery, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ScrapPersistedThroughRounds, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ReachedFloorTarget, default(ForPrimitives));
			if (HasBattery)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref BatteryCharge, default(ForPrimitives));
			}
		}

		public override void Write(FastBufferWriter writer)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0092: 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_00a9: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref StartFallingPosition);
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref FloorYRot, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref FallTime, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref HasHitGround, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref ScrapValue, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref ItemUsedUp, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsPocketed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsInElevator, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsBeingUsed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsInShipRoom, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsInFactory, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref Deactivated, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref ParentObject, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref HasBattery, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref ScrapPersistedThroughRounds, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref ReachedFloorTarget, default(ForPrimitives));
			if (HasBattery)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref BatteryCharge, default(ForPrimitives));
			}
		}
	}
	internal class RocketLaucherSynchronizationHandler : IItemSynchronisationHandler<MissileLauncher>
	{
		public int Ammo;

		public override void Apply(MissileLauncher item)
		{
			item.Ammo = Ammo;
		}

		public override void Read(MissileLauncher item)
		{
			Ammo = item.Ammo;
		}

		public override void Read(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Ammo, default(ForPrimitives));
		}

		public override void Write(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Ammo, default(ForPrimitives));
		}
	}
}
namespace AdvancedCompany.Network.Messages
{
	[Message("ActivateHelmetLamp", false, true)]
	internal class ActivateHelmetLamp : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal bool IsUsed;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}
	}
	[Message("ActivateTacticalHelmet", false, true)]
	internal class ActivateTacticalHelmet : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal bool IsUsed;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}
	}
	[Message("ActivateNightVision", false, true)]
	internal class ActivateVisionEnhancer : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal bool IsUsed;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsUsed, default(ForPrimitives));
		}
	}
	[Message("AttractAllEnemies", false, true)]
	internal class AttractAllEnemies : INamedMessage, ITransferable
	{
		public bool Inside;

		public int PlayerNum;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref Inside, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref Inside, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
		}
	}
	[Message("BuyItems", false, true)]
	internal class BuyItems : INamedMessage, ITransferable
	{
		public int NewCredits;

		public int[] Items;

		public int[] Unlockables;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref NewCredits, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Items, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Unlockables, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref NewCredits, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(Items, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(Unlockables, default(ForPrimitives));
		}
	}
	[Message("ChangeItemSlot", false, true)]
	internal class ChangeItemSlot : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal int FromSlot;

		internal int ToSlot;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref FromSlot, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref ToSlot, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref FromSlot, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref ToSlot, default(ForPrimitives));
		}
	}
	[Message("ChangePerk", false, true)]
	internal class ChangePerk : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal string ID;

		internal int Level;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref ID, false);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Level, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ID, false);
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Level, default(ForPrimitives));
		}
	}
	[Message("ChangeShip", false, true)]
	internal class ChangeShip : INamedMessage, ITransferable
	{
		internal int TotalQuota;

		internal bool ExtendedDeadline;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref TotalQuota, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ExtendedDeadline, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref TotalQuota, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref ExtendedDeadline, default(ForPrimitives));
		}
	}
	[Message("CosmeticsSync", false, true)]
	internal class CosmeticsSync : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal string[] Cosmetics;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			List<string> list = new List<string>();
			string item = default(string);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref item, false);
				list.Add(item);
			}
			Cosmetics = list.ToArray();
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			int num = Cosmetics.Length;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			for (int i = 0; i < Cosmetics.Length; i++)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(Cosmetics[i], false);
			}
		}
	}
	[Message("DeadlineChanged", false, false)]
	internal class DeadlineChanged : INamedMessage, ITransferable
	{
		internal float NewDeadline;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref NewDeadline, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref NewDeadline, default(ForPrimitives));
		}
	}
	[Message("DoomShotgun", false, true)]
	public class DoomShotgun : INamedMessage, ITransferable
	{
		public int PlayerNum;

		public Vector3 ShotgunPosition;

		public Vector3 ShotgunForward;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref ShotgunPosition);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref ShotgunForward);
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref ShotgunPosition);
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref ShotgunForward);
		}
	}
	[Message("ExtendDeadline", true, false)]
	internal class ExtendDeadline : INamedMessage, ITransferable
	{
		public void ReadData(FastBufferReader reader)
		{
		}

		public void WriteData(FastBufferWriter writer)
		{
		}
	}
	[Message("GrantPlayerXP", false, true)]
	internal class GrantPlayerXP : INamedMessage, ITransferable
	{
		internal bool All;

		internal int PlayerNum;

		internal int XP;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref All, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref XP, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref All, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref XP, default(ForPrimitives));
		}
	}
	[Message("GrantShipXP", false, true)]
	internal class GrantShipXP : INamedMessage, ITransferable
	{
		internal int XP;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref XP, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref XP, default(ForPrimitives));
		}
	}
	[Message("Respec", false, true)]
	internal class Respec : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal Perk.Type Type;

		internal bool Reset;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0024: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			int type = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref type, default(ForPrimitives));
			Type = (Perk.Type)type;
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref Reset, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			int type = (int)Type;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref type, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref Reset, default(ForPrimitives));
		}
	}
	[Message("RocketExplode", false, true)]
	internal class RocketExplode : INamedMessage, ITransferable
	{
		internal long ID;

		internal Vector3 Position;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref ID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Position);
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<long>(ref ID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Position);
		}
	}
	[Message("RocketJump", false, true)]
	internal class RocketJump : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
		}
	}
	[Message("SpawnRocket", false, true)]
	internal class SpawnRocket : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal long TempID;

		internal long ID;

		internal Vector3 Position;

		internal Quaternion Rotation;

		internal float TurbulenceTime;

		internal float TurbulenceSpeed;

		internal float TurbulenceStrength;

		internal float FlyTime;

		internal Color Color;

		internal double Time;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref TempID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref ID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Position);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Rotation);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceTime, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceSpeed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceStrength, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref FlyTime, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Color);
			((FastBufferReader)(ref reader)).ReadValueSafe<double>(ref Time, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<long>(ref TempID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<long>(ref ID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Position);
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Rotation);
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceTime, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceSpeed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceStrength, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref FlyTime, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Color);
			((FastBufferWriter)(ref writer)).WriteValueSafe<double>(ref Time, default(ForPrimitives));
		}
	}
	[Message("SpawnRocketFromClient", true, false)]
	internal class SpawnRocketFromClient : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal long TempID;

		internal Vector3 Position;

		internal Quaternion Rotation;

		internal float TurbulenceTime;

		internal float TurbulenceSpeed;

		internal float TurbulenceStrength;

		internal float FlyTime;

		internal Color Color;

		internal double Time;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref TempID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Position);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Rotation);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceTime, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceSpeed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref TurbulenceStrength, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref FlyTime, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref Color);
			((FastBufferReader)(ref reader)).ReadValueSafe<double>(ref Time, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<long>(ref TempID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Position);
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Rotation);
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceTime, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceSpeed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref TurbulenceStrength, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref FlyTime, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref Color);
			((FastBufferWriter)(ref writer)).WriteValueSafe<double>(ref Time, default(ForPrimitives));
		}
	}
	[Message("SwitchItem", false, true)]
	internal class SwitchItem : INamedMessage, ITransferable
	{
		internal int PlayerNum;

		internal int Slot;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Slot, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Slot, default(ForPrimitives));
		}
	}
	[Message("SyncAnimationOverride", false, true)]
	internal class SyncAnimationOverride : INamedMessage, ITransferable
	{
		public int PlayerNum;

		public string OriginalName;

		public string ReplacementName;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValue<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValue(ref OriginalName, true);
			((FastBufferReader)(ref reader)).ReadValue(ref ReplacementName, true);
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValue<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValue(OriginalName, true);
			((FastBufferWriter)(ref writer)).WriteValue(ReplacementName, true);
		}
	}
	[Message("SyncCurrentLevel", false, false)]
	internal class SyncCurrentLevel : INamedMessage, ITransferable
	{
		internal int CurrentLevelID;

		internal int CurrentWeather;

		internal int CurrentSeed;

		internal int[] DeadPlayers;

		internal int[] JoinedLate;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref CurrentLevelID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref CurrentSeed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref CurrentWeather, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref DeadPlayers, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref JoinedLate, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref CurrentLevelID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref CurrentSeed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref CurrentWeather, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(DeadPlayers, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(JoinedLate, default(ForPrimitives));
		}
	}
	[Message("UseFlashlight", false, true)]
	internal class UseFlashlight : INamedMessage, ITransferable
	{
		public int PlayerNum;

		public int Slot;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref Slot, default(ForPrimitives));
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Slot, default(ForPrimitives));
		}
	}
	[Message("UseMobileTerminal", false, true)]
	internal class UseMobileTerminal : INamedMessage, ITransferable
	{
		public int PlayerNum;

		public bool IsUsingTerminal;

		public string ConsoleText;

		public string InputText;

		public float Scroll;

		public void ReadData(FastBufferReader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref IsUsingTerminal, default(ForPrimitives));
			if (IsUsingTerminal)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref ConsoleText, false);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref InputText, false);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref Scroll, default(ForPrimitives));
			}
		}

		public void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref IsUsingTerminal, default(ForPrimitives));
			if (IsUsingTerminal)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(ConsoleText, false);
				((FastBufferWriter)(ref writer)).WriteValueSafe(InputText, false);
				((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref Scroll, default(ForPrimitives));
			}
		}
	}
}
namespace AdvancedCompany.Math
{
	public struct XXHash
	{
		private const uint PRIME32_1 = 2654435761u;

		private const uint PRIME32_2 = 2246822519u;

		private const uint PRIME32_3 = 3266489917u;

		private const uint PRIME32_4 = 668265263u;

		private const uint PRIME32_5 = 374761393u;

		public int Counter;

		public int Seed;

		public float Value => (float)GetHash(Counter) / 2.1474836E+09f;

		private static uint rotl32(uint x, int r)
		{
			return (x << r) | (x >> 32 - r);
		}

		public static uint GetHash(int data, int seed)
		{
			uint num = (uint)(seed + 374761393);
			num += 4;
			num += (uint)(data * -1028477379);
			num = rotl32(num, 17) * 668265263;
			num ^= num >> 15;
			num *= 2246822519u;
			num ^= num >> 13;
			num *= 3266489917u;
			return num ^ (num >> 16);
		}

		public XXHash(int seed)
		{
			Counter = 0;
			Seed = seed;
		}

		internal uint GetHash(int data)
		{
			return GetHash(data, Seed);
		}

		public int Range(int max)
		{
			Counter++;
			return (int)GetHash(Counter) % max;
		}

		public int Range(int min, int max)
		{
			Counter++;
			return (int)GetHash(Counter) % (max - min) + min;
		}
	}
}
namespace AdvancedCompany.Lib
{
	public class Cosmetics
	{
		internal static void LoadNew()
		{
			foreach (AssetBundle item in CosmeticRegistry.ToLoad)
			{
				LoadCosmeticsFromBundle(item);
			}
			CosmeticRegistry.ToLoad.Clear();
			foreach (GameObject item2 in CosmeticGeneric.ToLoad)
			{
				LoadCosmeticsFromPrefab(item2);
			}
			CosmeticGeneric.ToLoad.Clear();
		}

		public static GameObject[] GetSpawnedCosmetics(PlayerControllerB controller)
		{
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer((int)controller.playerClientId);
			return player.AppliedCosmetics.Values.ToArray();
		}

		public static void LoadCosmeticsFromPrefab(GameObject prefab)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			((Object)prefab).hideFlags = (HideFlags)32;
			CosmeticInstance cosmeticInstance = prefab.GetComponent<CosmeticInstance>();
			if ((Object)(object)cosmeticInstance == (Object)null)
			{
				CosmeticInstance component = prefab.GetComponent<CosmeticInstance>();
				if ((Object)(object)component != (Object)null)
				{
					cosmeticInstance = prefab.AddComponent<CosmeticInstance>();
					cosmeticInstance.cosmeticId = component.cosmeticId;
					cosmeticInstance.cosmeticType = Enum.Parse<CosmeticType>(Enum.GetName(typeof(CosmeticType), component.cosmeticType));
					cosmeticInstance.icon = component.icon;
					Object.Destroy((Object)(object)component);
				}
				else
				{
					Plugin.Log.LogWarning((object)("Error while loading cosmetic " + ((Object)prefab).name + ". No AdvancedCompany.Cosmetics.CosmeticInstance nor MoreCompany.Cosmetics.CosmeticInstance were present."));
				}
			}
			if ((Object)(object)cosmeticInstance != (Object)null)
			{
				CosmeticDatabase.AddCosmetic(cosmeticInstance);
			}
		}

		public static void LoadCosmeticsFromBundle(AssetBundle bundle)
		{
			if (!((Object)(object)bundle != (Object)null))
			{
				return;
			}
			string[] allAssetNames = bundle.GetAllAssetNames();
			foreach (string text in allAssetNames)
			{
				if (text.EndsWith(".prefab"))
				{
					GameObject prefab = bundle.LoadAsset<GameObject>(text);
					LoadCosmeticsFromPrefab(prefab);
				}
			}
		}
	}
	public class Equipment
	{
		public enum Slot
		{
			HEAD,
			BODY,
			FEET
		}

		public delegate void EquipmentListener(PlayerControllerB controller, Slot slot, GameObject[] objs);

		public static event EquipmentListener Listener;

		public static GameObject[] GetSpawnedEquipment(PlayerControllerB controller, Slot slot)
		{
			AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer((int)controller.playerClientId);
			if (player == null)
			{
				return (GameObject[])(object)new GameObject[0];
			}
			return slot switch
			{
				Slot.HEAD => player.EquipmentItemsHead.ToArray(), 
				Slot.BODY => player.EquipmentItemsBody.ToArray(), 
				Slot.FEET => player.EquipmentItemsFeet.ToArray(), 
				_ => (GameObject[])(object)new GameObject[0], 
			};
		}

		internal static void NewFeet(PlayerControllerB player, GameObject[] feet)
		{
			if (Equipment.Listener != null)
			{
				Equipment.Listener(player, Slot.FEET, feet);
			}
		}

		internal static void NewBody(PlayerControllerB player, GameObject[] body)
		{
			if (Equipment.Listener != null)
			{
				Equipment.Listener(player, Slot.BODY, body);
			}
		}

		internal static void NewHead(PlayerControllerB player, GameObject[] head)
		{
			if (Equipment.Listener != null)
			{
				Equipment.Listener(player, Slot.HEAD, head);
			}
		}
	}
	public class Flavour
	{
		internal static Sprite OverrideLogo;

		public static void SetLogo(Texture2D logo)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			OverrideLogo = Sprite.Create(logo, new Rect(0f, 0f, (float)((Texture)logo).width, (float)((Texture)logo).height), new Vector2(0.5f, 0.5f));
		}
	}
	internal class HDRP
	{
		public enum InjectionPoint
		{
			AFTER_POSTPROCESS,
			AFTER_POSTPROCESS_BLURS,
			BEFORE_POSTPROCESS,
			BEFORE_TAA,
			BEFORE_TRANSPARENT
		}

		[Flags]
		public enum PostProcessingFlags
		{
			OUTSIDE = 1,
			INSIDE = 2,
			ORBIT = 4,
			UNDERWATER = 8,
			ALL = 0xF
		}

		public class PostProcessInstance
		{
			public delegate void InstanceChanged(VolumeComponent old, VolumeComponent component);

			public InstanceChanged OnInstanceChanged;

			public VolumeComponent CurrentInstance { get; internal set; }
		}

		internal static Dictionary<string, Dictionary<PostProcessingFlags, VolumeProfile>> Profiles;

		internal static Dictionary<string, Dictionary<PostProcessingFlags, List<(Type, PostProcessInstance)>>> Components;

		internal static List<string> AfterPostProcessList;

		internal static List<string> AfterPostProcessBlursList;

		internal static List<string> BeforePostProcessList;

		internal static List<string> BeforeTAAList;

		internal static List<string> BeforeTransparentList;

		static HDRP()
		{
			Profiles = new Dictionary<string, Dictionary<PostProcessingFlags, VolumeProfile>>();
			Components = new Dictionary<string, Dictionary<PostProcessingFlags, List<(Type, PostProcessInstance)>>>();
			RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
			HDRenderPipelineAsset val = (HDRenderPipelineAsset)(object)((currentRenderPipeline is HDRenderPipelineAsset) ? currentRenderPipeline : null);
			Type type = typeof(HDRenderPipelineAsset).Assembly.GetType("UnityEngine.Rendering.HighDefinition.HDRenderPipelineGlobalSettings");
			PropertyInfo property = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			object value = property.GetValue(null);
			FieldInfo field = type.GetField("afterPostProcessCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			AfterPostProcessList = (List<string>)field.GetValue(value);
			FieldInfo field2 = type.GetField("afterPostProcessBlursCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			AfterPostProcessBlursList = (List<string>)field2.GetValue(value);
			FieldInfo field3 = type.GetField("beforePostProcessCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			BeforePostProcessList = (List<string>)field3.GetValue(value);
			FieldInfo field4 = type.GetField("beforeTAACustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			BeforeTAAList = (List<string>)field4.GetValue(value);
			FieldInfo field5 = type.GetField("beforeTransparentCustomPostProcesses", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
			BeforeTransparentList = (List<string>)field5.GetValue(value);
		}

		public static void AddCustomPostProcessing(InjectionPoint point, object obj)
		{
			if (obj != null)
			{
				AddCustomPostProcessing(point, obj.GetType().AssemblyQualifiedName);
			}
		}

		public static void AddCustomPostProcessing(InjectionPoint point, Type t)
		{
			if (!(t == null))
			{
				AddCustomPostProcessing(point, t.AssemblyQualifiedName);
			}
		}

		public static void AddCustomPostProcessing(InjectionPoint point, string className)
		{
			switch (point)
			{
			case InjectionPoint.AFTER_POSTPROCESS:
				if (!AfterPostProcessList.Contains(className))
				{
					AfterPostProcessList.Add(className);
				}
				break;
			case InjectionPoint.AFTER_POSTPROCESS_BLURS:
				if (!AfterPostProcessBlursList.Contains(className))
				{
					AfterPostProcessBlursList.Add(className);
				}
				break;
			case InjectionPoint.BEFORE_POSTPROCESS:
				if (!BeforePostProcessList.Contains(className))
				{
					BeforePostProcessList.Add(className);
				}
				break;
			case InjectionPoint.BEFORE_TAA:
				if (!BeforeTAAList.Contains(className))
				{
					BeforeTAAList.Add(className);
				}
				break;
			case InjectionPoint.BEFORE_TRANSPARENT:
				if (!BeforeTransparentList.Contains(className))
				{
					BeforeTransparentList.Add(className);
				}
				break;
			}
		}

		public static PostProcessInstance AddPostProcessing<T>(InjectionPoint point, PostProcessingFlags flags = PostProcessingFlags.ALL, string moonID = null) where T : IPostProcessComponent
		{
			AddCustomPostProcessing(point, typeof(T).AssemblyQualifiedName);
			if (moonID == null)
			{
				moonID = "_ALL";
			}
			if (!Components.ContainsKey(moonID))
			{
				Components.Add(moonID, new Dictionary<PostProcessingFlags, List<(Type, PostProcessInstance)>>
				{
					{
						PostProcessingFlags.OUTSIDE,
						new List<(Type, PostProcessInstance)>()
					},
					{
						PostProcessingFlags.INSIDE,
						new List<(Type, PostProcessInstance)>()
					},
					{
						PostProcessingFlags.ORBIT,
						new List<(Type, PostProcessInstance)>()
					},
					{
						PostProcessingFlags.UNDERWATER,
						new List<(Type, PostProcessInstance)>()
					}
				});
			}
			PostProcessInstance postProcessInstance = new PostProcessInstance();
			if ((flags & PostProcessingFlags.OUTSIDE) == PostProcessingFlags.OUTSIDE)
			{
				Components[moonID][PostProcessingFlags.OUTSIDE].Add((typeof(T), postProcessInstance));
			}
			if ((flags & PostProcessingFlags.INSIDE) == PostProcessingFlags.INSIDE)
			{
				Components[moonID][PostProcessingFlags.INSIDE].Add((typeof(T), postProcessInstance));
			}
			if ((flags & PostProcessingFlags.ORBIT) == PostProcessingFlags.ORBIT)
			{
				Components[moonID][PostProcessingFlags.ORBIT].Add((typeof(T), postProcessInstance));
			}
			if ((flags & PostProcessingFlags.UNDERWATER) == PostProcessingFlags.UNDERWATER)
			{
				Components[moonID][PostProcessingFlags.UNDERWATER].Add((typeof(T), postProcessInstance));
			}
			return postProcessInstance;
		}

		internal static VolumeProfile GetProfile(string moonID, PostProcessingFlags type)
		{
			if (moonID == null)
			{
				moonID = "_ALL";
			}
			if (!Profiles.ContainsKey(moonID))
			{
				Profiles.Add(moonID, new Dictionary<PostProcessingFlags, VolumeProfile>());
			}
			VolumeProfile val = null;
			if (!Profiles[moonID].ContainsKey(type))
			{
				val = ScriptableObject.CreateInstance<VolumeProfile>();
				((Object)val).hideFlags = (HideFlags)32;
				Profiles[moonID].Add(type, val);
				if (moonID != "_ALL" && Components.ContainsKey("_ALL") && Components["_ALL"].ContainsKey(type))
				{
					foreach (var item in Components["_ALL"][type])
					{
						val.Add(item.Item1, true);
					}
				}
				if (Components.ContainsKey(moonID) && Components[moonID].ContainsKey(type))
				{
					foreach (var item2 in Components[moonID][type])
					{
						val.Add(item2.Item1, true);
					}
				}
			}
			else
			{
				val = Profiles[moonID][type];
			}
			if (moonID != "_ALL" && Components.ContainsKey("_ALL") && Components["_ALL"].ContainsKey(type))
			{
				VolumeComponent val2 = default(VolumeComponent);
				foreach (var item3 in Components["_ALL"][type])
				{
					if (val.TryGet<VolumeComponent>(item3.Item1, ref val2))
					{
						VolumeComponent currentInstance = item3.Item2.CurrentInstance;
						item3.Item2.CurrentInstance = val2;
						if (item3.Item2.OnInstanceChanged != null)
						{
							item3.Item2.OnInstanceChanged(currentInstance, val2);
						}
					}
				}
			}
			if (Components.ContainsKey(moonID) && Components[moonID].ContainsKey(type))
			{
				VolumeComponent val3 = default(VolumeComponent);
				foreach (var item4 in Components[moonID][type])
				{
					if (val.TryGet<VolumeComponent>(item4.Item1, ref val3))
					{
						VolumeComponent currentInstance2 = item4.Item2.CurrentInstance;
						item4.Item2.CurrentInstance = val3;
						if (item4.Item2.OnInstanceChanged != null)
						{
							item4.Item2.OnInstanceChanged(currentInstance2, val3);
						}
					}
				}
			}
			return Profiles[moonID][type];
		}
	}
	public static class Mod
	{
		internal static string Hash;

		internal static Dictionary<string, string> RequiredMods = new Dictionary<string, string>();

		public static void RegisterRequiredMod(string modName, string modVersion)
		{
			Hash = null;
			RequiredMods[modName] = modVersion;
		}

		public static void RegisterRequiredMod(BaseUnityPlugin plugin)
		{
			if ((Object)(object)plugin != (Object)null)
			{
				Hash = null;
				BepInPlugin customAttribute = ((MemberInfo)((object)plugin).GetType()).GetCustomAttribute<BepInPlugin>();
				if (customAttribute != null)
				{
					RequiredMods.Add(customAttribute.GUID, customAttribute.Version.ToString());
				}
			}
		}

		public static string GetHash()
		{
			if (Hash == null)
			{
				List<string> list = RequiredMods.Keys.ToList();
				list.Sort();
				string text = "";
				for (int i = 0; i < list.Count; i++)
				{
					text = text + list[i] + RequiredMods[list[i]];
				}
				using MD5 mD = MD5.Create();
				byte[] array = mD.ComputeHash(Encoding.UTF8.GetBytes(text));
				StringBuilder stringBuilder = new StringBuilder();
				for (int j = 0; j < array.Length; j++)
				{
					stringBuilder.Append(array[j].ToString("X2"));
				}
				Hash = stringBuilder.ToString().ToLowerInvariant();
			}
			return Hash;
		}
	}
	public class Player
	{
		internal static Dictionary<string, AnimationClip> Animations = new Dictionary<string, AnimationClip>();

		public static void AddAnimation(AnimationClip clip)
		{
			if (!Animations.ContainsKey(((Object)clip).name))
			{
				Animations.Add(((Object)clip).name, clip);
			}
		}

		public static void SetAnimationOverride(PlayerControllerB player, string originalName, string newName, bool sync = true)
		{
			AdvancedCompany.Game.Player player2 = AdvancedCompany.Game.Player.GetPlayer(player);
			player2.AddOverride(originalName, newName, sync);
		}

		public static void RemoveAnimationOverride(PlayerControllerB player, string originalName, bool sync = true)
		{
			AdvancedCompany.Game.Player player2 = AdvancedCompany.Game.Player.GetPlayer(player);
			player2.RemoveOverride(originalName, sync);
		}
	}
	public class Sync
	{
		internal ConnectionApprovalResponse Response;

		internal bool IsFinished = false;

		private static List<Type> Syncers;

		private List<ISyncHandler> SyncHandlers = new List<ISyncHandler>();

		internal const ulong MagicLong = 1107727392uL;

		public ulong ClientId;

		internal ulong ConfigHash;

		internal string Error;

		public static void AddSyncHandler<T>() where T : ISyncHandler, new()
		{
			Syncers.Add(typeof(T));
		}

		internal Sync()
		{
			for (int i = 0; i < Syncers.Count; i++)
			{
				SyncHandlers.Add((ISyncHandler)Activator.CreateInstance(Syncers[i]));
			}
		}

		internal void WriteDataToPlayerJoiningLobby(FastBufferWriter writer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Writing data to client joining...");
			ulong num = 1107727392uL;
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
			int position = ((FastBufferWriter)(ref writer)).Position;
			int num2 = 0;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
			num2 = SyncHandlers.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
			Plugin.Log.LogDebug((object)("Writing data for a total of " + SyncHandlers.Count + " synchronizers."));
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				string identifier = SyncHandlers[i].GetIdentifier();
				Plugin.Log.LogDebug((object)("Writing data for " + identifier));
				((FastBufferWriter)(ref writer)).WriteValueSafe(identifier, true);
				int position2 = ((FastBufferWriter)(ref writer)).Position;
				num2 = 0;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
				SyncHandlers[i].WriteDataToPlayerJoiningLobby(this, writer);
				int position3 = ((FastBufferWriter)(ref writer)).Position;
				int num3 = position3 - position2 - 4;
				Plugin.Log.LogDebug((object)("Data size: " + num3));
				((FastBufferWriter)(ref writer)).Seek(position2);
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num3, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).Seek(position3);
			}
			int position4 = ((FastBufferWriter)(ref writer)).Position;
			((FastBufferWriter)(ref writer)).Seek(position);
			int num4 = position4 - position - 4;
			Plugin.Log.LogDebug((object)("Total package size: " + num4));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num4, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).Seek(position4);
		}

		internal void WriteDataToHostBeforeJoining(FastBufferWriter writer)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Writing handshake data before joining...");
			ulong num = 1107727392uL;
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
			int position = ((FastBufferWriter)(ref writer)).Position;
			int num2 = 0;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
			num2 = SyncHandlers.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
			Plugin.Log.LogDebug((object)("Writing data for a total of " + SyncHandlers.Count + " synchronizers."));
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				string identifier = SyncHandlers[i].GetIdentifier();
				Plugin.Log.LogDebug((object)("Writing data for " + identifier));
				((FastBufferWriter)(ref writer)).WriteValueSafe(identifier, true);
				int position2 = ((FastBufferWriter)(ref writer)).Position;
				num2 = 0;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num2, default(ForPrimitives));
				SyncHandlers[i].WriteDataToHostBeforeJoining(this, writer);
				int position3 = ((FastBufferWriter)(ref writer)).Position;
				int num3 = position3 - position2 - 4;
				Plugin.Log.LogDebug((object)("Data size: " + num3));
				((FastBufferWriter)(ref writer)).Seek(position2);
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num3, default(ForPrimitives));
				((FastBufferWriter)(ref writer)).Seek(position3);
			}
			int position4 = ((FastBufferWriter)(ref writer)).Position;
			((FastBufferWriter)(ref writer)).Seek(position);
			int num4 = position4 - position - 4;
			Plugin.Log.LogDebug((object)("Total package size: " + num4));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num4, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).Seek(position4);
		}

		internal int SearchMagicLong(FastBufferReader reader)
		{
			int position = ((FastBufferReader)(ref reader)).Position;
			((FastBufferReader)(ref reader)).Seek(0);
			byte[] array = new byte[((FastBufferReader)(ref reader)).Length];
			((FastBufferReader)(ref reader)).ReadBytes(ref array, array.Length, 0);
			((FastBufferReader)(ref reader)).Seek(position);
			for (int i = 0; i < array.Length - 8; i++)
			{
				ulong num = BitConverter.ToUInt64(array, i);
				if (num == 1107727392)
				{
					Plugin.Log.LogInfo((object)("Found magic long at position " + i));
					return i;
				}
			}
			return -1;
		}

		internal void ReadDataFromClientBeforeJoining(FastBufferReader reader)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Reading data from handshake...");
			ulong num = default(ulong);
			((FastBufferReader)(ref reader)).ReadValue<ulong>(ref num, default(ForPrimitives));
			if (num != 1107727392)
			{
				Plugin.Log.LogWarning((object)"Something interferred with the network handshake. Panic mode initiated. Please consider removing conflicting mods. Searching for magic long...");
				int num2 = SearchMagicLong(reader);
				if (num2 == -1)
				{
					Plugin.Log.LogError((object)"Handshake message was destroyed by another mod. Please report this to the dev and check your mods. Sorry, we can't continue past this point. :(");
					throw new Exception("Handshake message was destroyed by another mod. Please report this to the dev and check your mods. Sorry, we can't continue past this point. :(");
				}
				((FastBufferReader)(ref reader)).Seek(num2);
			}
			int num3 = default(int);
			((FastBufferReader)(ref reader)).ReadValue<int>(ref num3, default(ForPrimitives));
			Plugin.Log.LogDebug((object)("Total package size: " + num3));
			int num4 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num4, default(ForPrimitives));
			if (SyncHandlers.Count != num4)
			{
				Plugin.Log.LogWarning((object)("There was a mismatch in synchronizers. Have: " + SyncHandlers.Count + "; Received: " + num4));
			}
			Plugin.Log.LogDebug((object)("Reading a total of " + num4 + " synchronizers."));
			string text = default(string);
			int num5 = default(int);
			for (int i = 0; i < num4; i++)
			{
				if (Error != null)
				{
					break;
				}
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, true);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num5, default(ForPrimitives));
				Plugin.Log.LogDebug((object)("Reading block " + text + " with size " + num5));
				Plugin.Log.LogDebug((object)("Pointer: " + ((FastBufferReader)(ref reader)).Position));
				bool flag = false;
				for (int j = 0; j < SyncHandlers.Count; j++)
				{
					if (SyncHandlers[i].GetIdentifier() == text)
					{
						SyncHandlers[i].ReadDataFromClientBeforeJoining(this, reader);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					Plugin.Log.LogWarning((object)("Syncer " + text + " wasn't found!"));
					((FastBufferReader)(ref reader)).Seek(((FastBufferReader)(ref reader)).Position + num5);
				}
			}
		}

		internal void ReadDataFromJoiningLobby(FastBufferReader reader)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Log.LogMessage((object)"Reading data from lobby...");
			ulong num = default(ulong);
			((FastBufferReader)(ref reader)).ReadValue<ulong>(ref num, default(ForPrimitives));
			if (num != 1107727392)
			{
				Plugin.Log.LogWarning((object)"Something interferred with the network handshake. Panic mode initiated. Please consider removing conflicting mods. Searching for magic long...");
				int num2 = SearchMagicLong(reader);
				if (num2 == -1)
				{
					Plugin.Log.LogError((object)"Handshake message was destroyed by another mod. Please report this to the dev and check your mods. Sorry, we can't continue past this point. :(");
					throw new Exception("Handshake message was destroyed by another mod. Please report this to the dev and check your mods. Sorry, we can't continue past this point. :(");
				}
				((FastBufferReader)(ref reader)).Seek(num2);
			}
			int num3 = default(int);
			((FastBufferReader)(ref reader)).ReadValue<int>(ref num3, default(ForPrimitives));
			Plugin.Log.LogMessage((object)("Total package size: " + num3));
			int num4 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num4, default(ForPrimitives));
			if (SyncHandlers.Count != num4)
			{
				Plugin.Log.LogWarning((object)("There was a mismatch in synchronizers. Have: " + SyncHandlers.Count + "; Received: " + num4));
			}
			Plugin.Log.LogMessage((object)("Reading a total of " + num4 + " synchronizers."));
			string text = default(string);
			int num5 = default(int);
			for (int i = 0; i < num4; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, true);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num5, default(ForPrimitives));
				int position = ((FastBufferReader)(ref reader)).Position;
				Plugin.Log.LogMessage((object)("Reading block " + text + " with size " + num5));
				Plugin.Log.LogMessage((object)("Pointer: " + ((FastBufferReader)(ref reader)).Position));
				bool flag = false;
				for (int j = 0; j < SyncHandlers.Count; j++)
				{
					if (SyncHandlers[i].GetIdentifier() == text)
					{
						try
						{
							SyncHandlers[i].ReadDataFromJoiningLobby(this, reader);
							flag = true;
						}
						catch (Exception ex)
						{
							Plugin.Log.LogError((object)("Error while syncing " + text + " data:"));
							Plugin.Log.LogError((object)ex);
							((FastBufferReader)(ref reader)).Seek(position + num5);
							continue;
						}
						break;
					}
				}
				if (!flag)
				{
					Plugin.Log.LogWarning((object)("Syncer " + text + " wasn't found!"));
					((FastBufferReader)(ref reader)).Seek(((FastBufferReader)(ref reader)).Position + num5);
				}
			}
		}

		internal Sync PlayerJoining(ulong clientID)
		{
			return new Sync();
		}

		public T GetSyncHandler<T>() where T : ISyncHandler
		{
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				if (SyncHandlers[i] is T result)
				{
					return result;
				}
			}
			return default(T);
		}

		internal void LevelLoaded()
		{
			Plugin.Log.LogMessage((object)"Executing level loaded callback...");
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				try
				{
					if (SyncHandlers[i] is ILevelLoaded levelLoaded)
					{
						levelLoaded.LevelLoaded();
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error while applying " + SyncHandlers[i].GetIdentifier() + " synchronizer!"));
					Plugin.Log.LogError((object)ex);
				}
			}
		}

		internal void NetworkObjectsPlaced()
		{
			Plugin.Log.LogMessage((object)"Executing network objects placed callback...");
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				try
				{
					if (SyncHandlers[i] is INetworkObjectsPlaced networkObjectsPlaced)
					{
						networkObjectsPlaced.NetworkObjectsPlaced();
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error while applying " + SyncHandlers[i].GetIdentifier() + " synchronizer!"));
					Plugin.Log.LogError((object)ex);
				}
			}
		}

		internal void ConnectClientToPlayerObject(PlayerControllerB player)
		{
			Plugin.Log.LogMessage((object)"Executing connect client to player object callback...");
			for (int i = 0; i < SyncHandlers.Count; i++)
			{
				try
				{
					if (SyncHandlers[i] is IConnectClientToPlayerObject connectClientToPlayerObject)
					{
						connectClientToPlayerObject.ConnectClientToPlayerObject(player);
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("Error while applying " + SyncHandlers[i].GetIdentifier() + " synchronizer!"));
					Plugin.Log.LogError((object)ex);
				}
			}
		}

		public void SetError(string connectionError)
		{
			Error = connectionError;
		}

		static Sync()
		{
			Syncers = new List<Type>();
			AddSyncHandler<LobbyDataSynchronization>();
			AddSyncHandler<RedLocustBeesSynchronization>();
			AddSyncHandler<ItemSynchronization>();
			AddSyncHandler<DoorLockSynchronization>();
			AddSyncHandler<AnimatedObjectTriggerSynchronization>();
			AddSyncHandler<OtherSynchronization>();
		}
	}
}
namespace AdvancedCompany.Lib.SyncHandler
{
	public interface IItemSynchronizationHandler
	{
		void ReadObject(GrabbableObject item);

		void ApplyObject(GrabbableObject item);

		void Read(FastBufferReader reader);

		void Write(FastBufferWriter writer);
	}
	public abstract class IItemSynchronisationHandler<T> : IItemSynchronizationHandler where T : GrabbableObject
	{
		public abstract void Read(T item);

		public abstract void Apply(T item);

		public void ReadObject(GrabbableObject item)
		{
			Read((T)(object)item);
		}

		public void ApplyObject(GrabbableObject item)
		{
			Apply((T)(object)item);
		}

		public abstract void Read(FastBufferReader reader);

		public abstract void Write(FastBufferWriter writer);
	}
	public interface ISyncHandler
	{
		string GetIdentifier();

		void WriteDataToPlayerJoiningLobby(Sync sync, FastBufferWriter writer);

		void ReadDataFromJoiningLobby(Sync sync, FastBufferReader reader);

		void WriteDataToHostBeforeJoining(Sync sync, FastBufferWriter writer);

		void ReadDataFromClientBeforeJoining(Sync sync, FastBufferReader reader);
	}
	public class ItemSynchronization : ISyncHandler, INetworkObjectsPlaced
	{
		private static Dictionary<Type, Type> Types;

		private static Dictionary<string, Type> TypesByName;

		internal List<IItemSynchronizationHandler> Items = new List<IItemSynchronizationHandler>();

		internal List<ulong> NetworkIDs = new List<ulong>();

		static ItemSynchronization()
		{
			Types = new Dictionary<Type, Type>();
			TypesByName = new Dictionary<string, Type>();
			AddItemType<GrabbableObjectSynchronizationHandler>();
			AddItemType<RocketLaucherSynchronizationHandler>();
			AddItemType<BulletProofVestSynchronizationHandler>();
		}

		public static void AddItemType<T>() where T : IItemSynchronizationHandler, new()
		{
			Type type = typeof(T);
			Type type2 = null;
			while (type != null)
			{
				Type[] genericArguments = type.GetGenericArguments();
				if (genericArguments.Length != 0)
				{
					type2 = genericArguments[0];
					break;
				}
				type = type.BaseType;
			}
			Types[type2] = typeof(T);
			TypesByName[type2.Name] = typeof(T);
		}

		public string GetIdentifier()
		{
			return "AdvCmpny.Items";
		}

		public void NetworkObjectsPlaced()
		{
			for (int i = 0; i < Items.Count; i++)
			{
				ulong key = NetworkIDs[i];
				if (NetworkManager.Singleton.SpawnManager.SpawnedObjects.ContainsKey(key))
				{
					Plugin.Log.LogMessage((object)("Applying properties for network object " + key));
					NetworkObject val = NetworkManager.Singleton.SpawnManager.SpawnedObjects[key];
					GrabbableObject component = ((Component)val).GetComponent<GrabbableObject>();
					Items[i].ApplyObject(component);
				}
				else
				{
					Plugin.Log.LogWarning((object)("Network object with ID " + key + " was not found!"));
				}
			}
		}

		public void ReadDataFromClientBeforeJoining(Sync sync, FastBufferReader reader)
		{
		}

		public void ReadDataFromJoiningLobby(Sync sync, FastBufferReader reader)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			ulong item = default(ulong);
			int num2 = default(int);
			string text = default(string);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref item, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				for (int j = 0; j < num2; j++)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref text, true);
					if (TypesByName.ContainsKey(text))
					{
						IItemSynchronizationHandler itemSynchronizationHandler = (IItemSynchronizationHandler)Activator.CreateInstance(TypesByName[text]);
						itemSynchronizationHandler.Read(reader);
						Items.Add(itemSynchronizationHandler);
						NetworkIDs.Add(item);
						continue;
					}
					Plugin.Log.LogError((object)("Lobby data wasn't parseable. Missing type handler for: " + text));
					break;
				}
			}
		}

		public void WriteDataToHostBeforeJoining(Sync sync, FastBufferWriter writer)
		{
		}

		public void WriteDataToPlayerJoiningLobby(Sync sync, FastBufferWriter writer)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			Dictionary<ulong, List<(string, IItemSynchronizationHandler)>> dictionary = new Dictionary<ulong, List<(string, IItemSynchronizationHandler)>>();
			for (int i = 0; i < array.Length; i++)
			{
				Type type = ((object)array[i]).GetType();
				NetworkObject component = ((Component)array[i]).GetComponent<NetworkObject>();
				if (!((Object)(object)component != (Object)null))
				{
					continue;
				}
				List<(string, IItemSynchronizationHandler)> list = new List<(string, IItemSynchronizationHandler)>();
				while (type != null)
				{
					if (Types.ContainsKey(type))
					{
						IItemSynchronizationHandler itemSynchronizationHandler = (IItemSynchronizationHandler)Activator.CreateInstance(Types[type]);
						list.Add((type.Name, itemSynchronizationHandler));
						itemSynchronizationHandler.ReadObject(array[i]);
					}
					type = type.BaseType;
				}
				dictionary[component.NetworkObjectId] = list;
			}
			int count = dictionary.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (KeyValuePair<ulong, List<(string, IItemSynchronizationHandler)>> item in dictionary)
			{
				ulong key = item.Key;
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref key, default(ForPrimitives));
				count = item.Value.Count;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
				foreach (var item2 in item.Value)
				{
					((FastBufferWriter)(ref writer)).WriteValueSafe(item2.Item1, true);
					item2.Item2.Write(writer);
				}
			}
		}
	}
}
namespace AdvancedCompany.Lib.SyncCallbacks
{
	public interface IConnectClientToPlayerObject
	{
		void ConnectClientToPlayerObject(PlayerControllerB player);
	}
	public interface ILevelLoaded
	{
		void LevelLoaded();
	}
	public interface INetworkObjectsPlaced
	{
		void NetworkObjectsPlaced();
	}
}
namespace AdvancedCompany.IL
{
	internal static class Patches
	{
		internal static MethodInfo GetMultiplierPlayer;

		internal static MethodInfo GetMultiplier;

		static Patches()
		{
			MethodInfo[] methods = typeof(Perks).GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo in array)
			{
				if (methodInfo.Name == "GetMultiplier")
				{
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (parameters.Length == 1)
					{
						GetMultiplier = methodInfo;
					}
					else if (parameters.Length == 2 && parameters[0].ParameterType.Name == "PlayerControllerB")
					{
						GetMultiplierPlayer = methodInfo;
					}
				}
			}
		}

		public static void AddMultiplierInstruction(string perkName, List<CodeInstruction> instructions, int pos, bool addMul = true)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			list.Add(new CodeInstruction(OpCodes.Ldstr, (object)perkName));
			list.Add(new CodeInstruction(OpCodes.Call, (object)GetMultiplier));
			if (addMul)
			{
				list.Add(new CodeInstruction(OpCodes.Mul, (object)null));
			}
			instructions.InsertRange(pos, list);
		}

		public static void AddWeightMultiplierInstruction(string perkName, List<CodeInstruction> instructions, int pos)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			list.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)1f));
			list.Add(new CodeInstruction(OpCodes.Sub, (object)null));
			list.Add(new CodeInstruction(OpCodes.Ldstr, (object)perkName));
			list.Add(new CodeInstruction(OpCodes.Call, (object)GetMultiplier));
			list.Add(new CodeInstruction(OpCodes.Mul, (object)null));
			list.Add(new CodeInstruction(OpCodes.Ldc_R4, (object)1f));
			list.Add(new CodeInstruction(OpCodes.Add, (object)null));
			instructions.InsertRange(pos, list);
		}

		public static void AddMultiplierPlayerInstruction(string perkName, List<CodeInstruction> instructions, int pos, bool addMul = true)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			list.Add(new CodeInstruction(OpCodes.Ldstr, (object)perkName));
			list.Add(new CodeInstruction(OpCodes.Call, (object)GetMultiplierPlayer));
			if (addMul)
			{
				list.Add(new CodeInstruction(OpCodes.Mul, (object)null));
			}
			instructions.InsertRange(pos, list);
		}
	}
}
namespace AdvancedCompany.Hooks.PlayerControllerB
{
	internal class KillPlayer
	{
		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPrefix]
		public static bool PrePatch(PlayerControllerB __instance, Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			bool flag = (Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController;
			if (__instance.currentlyHeldObjectServer is PietSmietController pietSmietController && !pietSmietController.CurseLifted && flag)
			{
				if ((int)causeOfDeath == 5 || (int)causeOfDeath == 2)
				{
					return true;
				}
				pietSmietController.Damage(10);
				if (pietSmietController.Health <= 0)
				{
					pietSmietController.StopDoom();
					return true;
				}
				return false;
			}
			if (((NetworkBehaviour)__instance).IsOwner && !__instance.isPlayerDead && __instance.AllowPlayerDeath())
			{
				AdvancedCompany.Game.Player player = AdvancedCompany.Game.Player.GetPlayer(__instance);
				player.UnequipAll();
			}
			if (flag)
			{
				Volumes.ChangeEnvironment(RoundManager.Instance.currentLevel.PlanetName, onMoon: true, GameNetworkManager.Instance.localPlayerController.isInsideFactory, underwater: false, GameNetworkManager.Instance.localPlayerController.isPlayerDead);
			}
			return true;
		}
	}
}
namespace AdvancedCompany.Game
{
	internal class BaseUpgradeable : IUpgradeable, ITransferable
	{
		public int XP;

		public Dictionary<string, int> Levels = new Dictionary<string, int>();

		public int UsedXP
		{
			get
			{
				int num = 0;
				foreach (KeyValuePair<string, Perk> perk in Perk.Perks)
				{
					int totalPrice = perk.Value.GetTotalPrice(perk.Value.GetLevel(this));
					num += totalPrice;
				}
				return num;
			}
		}

		public int RemainingXP => XP - UsedXP;

		public int GetLevel(Perk perk)
		{
			if (Levels.ContainsKey(perk.ID))
			{
				return Levels[perk.ID];
			}
			return 0;
		}

		public void SetLevel(Perk perk, int level)
		{
			if (!Levels.ContainsKey(perk.ID))
			{
				Levels.Add(perk.ID, level);
			}
			else
			{
				Levels[perk.ID] = level;
			}
		}

		public virtual void Reset(bool resetXP)
		{
			Levels.Clear();
			if (resetXP)
			{
				XP = 0;
			}
		}

		public virtual void ReadData(FastBufferReader reader)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Levels.Clear();
			int xP = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref xP, default(ForPrimitives));
			XP = xP;
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			string key = default(string);
			int value = default(int);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref key, true);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref value, default(ForPrimitives));
				Levels[key] = value;
			}
		}

		public virtual void WriteData(FastBufferWriter writer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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)
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref XP, default(ForPrimitives));
			int count = Levels.Count;
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			foreach (KeyValuePair<string, int> level in Levels)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(level.Key, true);
				count = level.Value;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
			}
		}
	}
	internal class ItemRuntimeData
	{
		public Item Item;

		public TerminalNode BuyConfirmationNode;

		public TerminalNode BuyCompletedNode;

		public TerminalKeyword Keyword;

		public CompatibleNoun Noun;

		public void Apply(TerminalKeyword buyKeyword, List<TerminalKeyword> keywords, List<CompatibleNoun> buyNouns, TerminalNode cancelPurchaseNode, TerminalKeyword confirmKeyword, TerminalKeyword denyKeyword, List<Item> buyableItemsList)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			int num = buyableItemsList.IndexOf(Item);
			if (num == -1)
			{
				num = buyableItemsList.Count;
				buyableItemsList.Add(Item);
			}
			string text = Item.itemName.Replace(" ", "-");
			BuyCompletedNode.buyItemIndex = num;
			BuyConfirmationNode.buyItemIndex = num;
			BuyConfirmationNode.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
			{
				new CompatibleNoun
				{
					noun = confirmKeyword,
					result = BuyCompletedNode
				},
				new CompatibleNoun
				{
					noun = denyKeyword,
					result = cancelPurchaseNode
				}
			};
			Keyword.defaultVerb = buyKeyword;
			if (!keywords.Contains(Keyword))
			{
				keywords.Add(Keyword);
			}
			if (!buyNouns.Contains(Noun))
			{
				buyNouns.Insert(0, Noun);
			}
		}
	}
	internal interface IUpgradeable
	{
		int GetLevel(Perk perk);

		void SetLevel(Perk perk, int level);
	}
	[Bootable]
	[HarmonyPatch]
	internal class Manager
	{
		public delegate void GameOver();

		public delegate void GameStarted();

		internal class Enemies
		{
			internal class Enemy
			{
				public EnemyType EnemyType;

				public LobbyConfiguration.EnemyConfig Config;

				public int GetPowerLevel(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverridePowerLevel)
					{
						return Config.PowerLevel;
					}
					return found;
				}
			}

			internal static List<Enemy> AllEnemies = new List<Enemy>();

			internal static Dictionary<string, Enemy> EnemiesByName = new Dictionary<string, Enemy>();

			internal static void SearchEnemies()
			{
				AllEnemies = new List<Enemy>();
				EnemiesByName = new Dictionary<string, Enemy>();
				Plugin.Log.LogMessage((object)"Searching for enemies...");
				for (int i = 0; i < StartOfRound.Instance.levels.Length; i++)
				{
					SelectableLevel val = StartOfRound.Instance.levels[i];
					foreach (SpawnableEnemyWithRarity enemy4 in val.Enemies)
					{
						if (!EnemiesByName.ContainsKey(enemy4.enemyType.enemyName))
						{
							Enemy enemy = new Enemy
							{
								Config = (LobbyConfiguration.AllEnemiesConfig.Enemies.ContainsKey(enemy4.enemyType.enemyName) ? LobbyConfiguration.AllEnemiesConfig.Enemies[enemy4.enemyType.enemyName] : null),
								EnemyType = enemy4.enemyType
							};
							AllEnemies.Add(enemy);
							EnemiesByName.Add(enemy4.enemyType.enemyName, enemy);
						}
					}
					foreach (SpawnableEnemyWithRarity outsideEnemy in val.OutsideEnemies)
					{
						if (!EnemiesByName.ContainsKey(outsideEnemy.enemyType.enemyName))
						{
							Enemy enemy2 = new Enemy
							{
								Config = (LobbyConfiguration.AllEnemiesConfig.Enemies.ContainsKey(outsideEnemy.enemyType.enemyName) ? LobbyConfiguration.AllEnemiesConfig.Enemies[outsideEnemy.enemyType.enemyName] : null),
								EnemyType = outsideEnemy.enemyType
							};
							AllEnemies.Add(enemy2);
							EnemiesByName.Add(outsideEnemy.enemyType.enemyName, enemy2);
						}
					}
					foreach (SpawnableEnemyWithRarity daytimeEnemy in val.DaytimeEnemies)
					{
						if (!EnemiesByName.ContainsKey(daytimeEnemy.enemyType.enemyName))
						{
							Enemy enemy3 = new Enemy
							{
								Config = (LobbyConfiguration.AllEnemiesConfig.Enemies.ContainsKey(daytimeEnemy.enemyType.enemyName) ? LobbyConfiguration.AllEnemiesConfig.Enemies[daytimeEnemy.enemyType.enemyName] : null),
								EnemyType = daytimeEnemy.enemyType
							};
							AllEnemies.Add(enemy3);
							EnemiesByName.Add(daytimeEnemy.enemyType.enemyName, enemy3);
						}
					}
					Plugin.Log.LogDebug((object)("Found enemies: " + string.Join(", ", EnemiesByName.Keys)));
				}
				AllEnemies = AllEnemies.OrderBy((Enemy a) => a.EnemyType.enemyName).ToList();
				LobbyConfiguration.AllEnemiesConfig.Enemies.Clear();
				foreach (Enemy allEnemy in AllEnemies)
				{
					LobbyConfiguration.AllEnemiesConfig.Enemies.Add(allEnemy.EnemyType.enemyName, new LobbyConfiguration.EnemyConfig
					{
						Active = true,
						OverridePowerLevel = false,
						PowerLevel = allEnemy.EnemyType.PowerLevel
					});
				}
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "advancedcompany", "enemies.json"), ((JToken)LobbyConfiguration.AllEnemiesConfig.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>()));
			}

			public static bool IsSpawnable(EnemyType enemy)
			{
				try
				{
					return ServerConfiguration.Instance.Enemies.GetByEnemyName(enemy.enemyName)?.Active ?? true;
				}
				catch (Exception)
				{
					return true;
				}
			}

			public static int GetPowerLevel(EnemyType enemy)
			{
				if (EnemiesByName.ContainsKey(enemy.enemyName))
				{
					return EnemiesByName[enemy.enemyName].GetPowerLevel(enemy.PowerLevel);
				}
				return enemy.PowerLevel;
			}
		}

		internal class Items
		{
			public static Dictionary<string, bool> ItemActivation;

			public static List<Item> AllItems;

			public static List<Item> ScrapItems;

			public static Dictionary<string, Item> ScrapItemsByName;

			public static List<Item> BuyableItems;

			public static List<UnlockableItem> ShipUpgrades;

			public static List<UnlockableItem> Decorations;

			public static Dictionary<UnlockableItem, int> UnlockablePrices = new Dictionary<UnlockableItem, int>();

			internal static void SearchItems()
			{
				Plugin.Log.LogMessage((object)"Searching for all items...");
				AllItems = new List<Item>();
				ScrapItems = new List<Item>();
				BuyableItems = new List<Item>();
				ShipUpgrades = new List<UnlockableItem>();
				Decorations = new List<UnlockableItem>();
				ScrapItemsByName = new Dictionary<string, Item>();
				ItemActivation = new Dictionary<string, bool>();
				Plugin.Log.LogMessage((object)"Searching for scrap...");
				for (int i = 0; i < StartOfRound.Instance.levels.Length; i++)
				{
					SelectableLevel val = StartOfRound.Instance.levels[i];
					for (int j = 0; j < val.spawnableScrap.Count; j++)
					{
						SpawnableItemWithRarity val2 = val.spawnableScrap[j];
						if (!ScrapItems.Contains(val2.spawnableItem))
						{
							if (!ScrapItemsByName.ContainsKey(val2.spawnableItem.itemName))
							{
								ScrapItems.Add(val2.spawnableItem);
								ScrapItemsByName.Add(val2.spawnableItem.itemName, val2.spawnableItem);
							}
							else
							{
								Plugin.Log.LogWarning((object)("New scrap item found, but the name " + val2.spawnableItem.itemName + " was already used!"));
							}
						}
						if (!AllItems.Contains(val2.spawnableItem))
						{
							AllItems.Add(val2.spawnableItem);
						}
					}
				}
				Plugin.Log.LogDebug((object)("Found scrap: " + string.Join(", ", ScrapItemsByName.Keys)));
				Plugin.Log.LogMessage((object)"Searching for buyable items...");
				HashSet<string> hashSet = new HashSet<string>();
				HashSet<string> hashSet2 = new HashSet<string>();
				HashSet<string> hashSet3 = new HashSet<string>();
				for (int k = 0; k < Terminal.terminalNodes.allKeywords.Length; k++)
				{
					TerminalKeyword val3 = Terminal.terminalNodes.allKeywords[k];
					if (!((Object)(object)val3 != (Object)null) || val3.compatibleNouns == null)
					{
						continue;
					}
					for (int l = 0; l < val3.compatibleNouns.Length; l++)
					{
						CompatibleNoun val4 = val3.compatibleNouns[l];
						if (!((Object)(object)val4.result != (Object)null))
						{
							continue;
						}
						if (val4.result.buyItemIndex >= 0)
						{
							if (val4.result.buyItemIndex < Terminal.buyableItemsList.Length)
							{
								Item val5 = Terminal.buyableItemsList[val4.result.buyItemIndex];
								if ((Object)(object)val5 == (Object)null)
								{
									Plugin.Log.LogWarning((object)("The item " + val4.noun.word + "(" + ((Object)val4.result).name + ") is null? This is unexpected behaviour. Item wont be added."));
									continue;
								}
								if (!BuyableItems.Contains(val5))
								{
									if (hashSet.Contains(val5.itemName))
									{
										hashSet.Add(val5.itemName);
									}
									BuyableItems.Add(val5);
								}
								if (!AllItems.Contains(val5))
								{
									AllItems.Add(val5);
								}
							}
							else
							{
								Plugin.Log.LogWarning((object)("The item " + val4.noun.word + "(" + ((Object)val4.result).name + ") wasn't added to buyableItemsList. This is unexpected behaviour. Item wont be added."));
							}
						}
						else
						{
							if (val4.result.shipUnlockableID < 0 || StartOfRound.Instance.unlockablesList.unlockables.Count <= val4.result.shipUnlockableID)
							{
								continue;
							}
							UnlockableItem val6 = StartOfRound.Instance.unlockablesList.unlockables[val4.result.shipUnlockableID];
							UnlockablePrices[val6] = val4.result.itemCost;
							if (val6.alwaysInStock)
							{
								if (!ShipUpgrades.Contains(val6))
								{
									if (hashSet3.Contains(val6.unlockableName))
									{
										hashSet3.Add(val6.unlockableName);
									}
									ShipUpgrades.Add(val6);
								}
							}
							else if (!Decorations.Contains(val6))
							{
								if (hashSet2.Contains(val6.unlockableName))
								{
									hashSet2.Add(val6.unlockableName);
								}
								Decorations.Add(val6);
							}
						}
					}
				}
				for (int m = 0; m < StartOfRound.Instance.unlockablesList.unlockables.Count; m++)
				{
					UnlockableItem val7 = StartOfRound.Instance.unlockablesList.unlockables[m];
					if (!((Object)(object)val7.shopSelectionNode != (Object)null))
					{
						continue;
					}
					UnlockablePrices[val7] = val7.shopSelectionNode.itemCost;
					if (val7.alwaysInStock)
					{
						if (!ShipUpgrades.Contains(val7))
						{
							if (hashSet3.Contains(val7.unlockableName))
							{
								hashSet3.Add(val7.unlockableName);
							}
							ShipUpgrades.Add(val7);
						}
					}
					else if (!Decorations.Contains(val7))
					{
						if (hashSet2.Contains(val7.unlockableName))
						{
							hashSet2.Add(val7.unlockableName);
						}
						Decorations.Add(val7);
					}
				}
				Plugin.Log.LogDebug((object)("Found buyable items: " + string.Join(", ", hashSet)));
				Plugin.Log.LogDebug((object)("Found decorations: " + string.Join(", ", hashSet2)));
				Plugin.Log.LogDebug((object)("Found upgrades: " + string.Join(", ", hashSet3)));
				AllItems = AllItems.OrderBy((Item a) => a.itemName).ToList();
				ScrapItems = ScrapItems.OrderBy((Item a) => a.itemName).ToList();
				BuyableItems = BuyableItems.OrderBy((Item a) => a.itemName).ToList();
				Decorations = Decorations.OrderBy((UnlockableItem a) => a.unlockableName).ToList();
				ShipUpgrades = ShipUpgrades.OrderBy((UnlockableItem a) => a.unlockableName).ToList();
				LobbyConfiguration.AllItemsConfig.Items.Clear();
				foreach (Item buyableItem in BuyableItems)
				{
					LobbyConfiguration.AllItemsConfig.Items.Add(buyableItem.itemName, new LobbyConfiguration.ItemConfig
					{
						Active = true,
						MaxDiscount = buyableItem.highestSalePercentage,
						Price = buyableItem.creditsWorth,
						Weight = buyableItem.weight
					});
				}
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "advancedcompany", "items.json"), ((JToken)LobbyConfiguration.AllItemsConfig.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>()));
				LobbyConfiguration.AllScrapConfig.Items.Clear();
				foreach (Item scrapItem in ScrapItems)
				{
					LobbyConfiguration.AllScrapConfig.Items.Add(scrapItem.itemName, new LobbyConfiguration.ScrapConfig
					{
						Active = true,
						MaxValue = scrapItem.maxValue,
						MinValue = scrapItem.minValue,
						Weight = scrapItem.weight
					});
				}
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "advancedcompany", "scrap.json"), ((JToken)LobbyConfiguration.AllScrapConfig.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>()));
				LobbyConfiguration.AllUnlockablesConfig.Unlockables.Clear();
				foreach (UnlockableItem decoration in Decorations)
				{
					if (!LobbyConfiguration.AllUnlockablesConfig.Unlockables.ContainsKey(decoration.unlockableName) && UnlockablePrices[decoration] > -1)
					{
						LobbyConfiguration.AllUnlockablesConfig.Unlockables.Add(decoration.unlockableName, new LobbyConfiguration.UnlockableConfig
						{
							Active = true,
							Price = UnlockablePrices[decoration]
						});
					}
				}
				foreach (UnlockableItem shipUpgrade in ShipUpgrades)
				{
					if (!LobbyConfiguration.AllUnlockablesConfig.Unlockables.ContainsKey(shipUpgrade.unlockableName) && UnlockablePrices[shipUpgrade] > -1)
					{
						LobbyConfiguration.AllUnlockablesConfig.Unlockables.Add(shipUpgrade.unlockableName, new LobbyConfiguration.UnlockableConfig
						{
							Active = true,
							Price = UnlockablePrices[shipUpgrade]
						});
					}
				}
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "advancedcompany", "unlockables.json"), ((JToken)LobbyConfiguration.AllUnlockablesConfig.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>()));
			}

			public static bool IsSpawnable(Item item)
			{
				try
				{
					return ServerConfiguration.Instance.Items.GetByScrapName(item.itemName)?.Active ?? true;
				}
				catch (Exception)
				{
					return true;
				}
			}

			public static bool IsBuyable(Item item)
			{
				try
				{
					return ServerConfiguration.Instance.Items.GetByItemName(item.itemName)?.Active ?? true;
				}
				catch (Exception)
				{
					return true;
				}
			}

			public static bool IsUnlockableBuyable(UnlockableItem item)
			{
				try
				{
					return ServerConfiguration.Instance.Items.GetByUnlockableName(item.unlockableName)?.Active ?? true;
				}
				catch (Exception)
				{
					return true;
				}
			}

			public static int GetItemSalesPercentage(Item item)
			{
				int num = -1;
				for (int i = 0; i < Terminal.buyableItemsList.Length; i++)
				{
					if ((Object)(object)Terminal.buyableItemsList[i] == (Object)(object)item)
					{
						num = i;
						break;
					}
				}
				if (num > -1)
				{
					return Terminal.itemSalesPercentages[num];
				}
				return 100;
			}

			public static float GetItemWeight(Item item)
			{
				if (item.isScrap)
				{
					LobbyConfiguration.ScrapConfig byScrapName = ServerConfiguration.Instance.Items.GetByScrapName(item.itemName);
					return (byScrapName == null || !byScrapName.OverrideWeight) ? item.weight : byScrapName.Weight;
				}
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(item.itemName);
				return (byItemName == null || !byItemName.OverrideWeight) ? item.weight : byItemName.Weight;
			}

			public static int GetItemMinValue(Item item)
			{
				LobbyConfiguration.ScrapConfig byScrapName = ServerConfiguration.Instance.Items.GetByScrapName(item.itemName);
				return (byScrapName == null || !byScrapName.OverrideMinValue) ? item.minValue : byScrapName.MinValue;
			}

			public static int GetItemMaxValue(Item item)
			{
				LobbyConfiguration.ScrapConfig byScrapName = ServerConfiguration.Instance.Items.GetByScrapName(item.itemName);
				return (byScrapName == null || !byScrapName.OverrideMaxValue) ? item.maxValue : byScrapName.MaxValue;
			}

			public static int GetItemHighestSalePercentage(Item item)
			{
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(item.itemName);
				if (byItemName != null && !byItemName.Active)
				{
					return 0;
				}
				return (byItemName == null || !byItemName.OverrideMaxDiscount) ? item.highestSalePercentage : byItemName.MaxDiscount;
			}

			public static int GetItemPrice(Item item, bool discount = false)
			{
				LobbyConfiguration.ItemConfig byItemName = ServerConfiguration.Instance.Items.GetByItemName(item.itemName);
				float num = (discount ? ((float)GetItemSalesPercentage(item) / 100f) : 1f);
				return Mathf.FloorToInt((byItemName == null || !byItemName.OverridePrice) ? ((float)item.creditsWorth * num) : ((float)byItemName.Price * num));
			}

			public static int GetUnlockablePrice(UnlockableItem unlockable)
			{
				LobbyConfiguration.UnlockableConfig byUnlockableName = ServerConfiguration.Instance.Items.GetByUnlockableName(unlockable.unlockableName);
				return (byUnlockableName == null || !byUnlockableName.OverridePrice) ? UnlockablePrices[unlockable] : byUnlockableName.Price;
			}

			public static int GetItemPriceTranspiler(Item item)
			{
				return GetItemPrice(item);
			}
		}

		public class Moons
		{
			internal class Moon
			{
				public SelectableLevel Level;

				public LobbyConfiguration.MoonConfig Config;

				private Dictionary<string, int> _OverrideDaytimeEnemies;

				private Dictionary<string, int> _OverrideOutsideEnemies;

				private Dictionary<string, int> _OverrideInsideEnemies;

				private Dictionary<string, int> _OverrideLoot;

				private List<SpawnableEnemyWithRarity> _CurrentDaytimeEnemies;

				private List<SpawnableEnemyWithRarity> _CurrentOutsideEnemies;

				private List<SpawnableEnemyWithRarity> _CurrentInsideEnemies;

				private List<SpawnableItemWithRarity> _CurrentLoot;

				public float? GetScrapAmountModifier()
				{
					if (Config == null)
					{
						return null;
					}
					if (Config.OverrideScrapAmountModifier)
					{
						return Config.ScrapAmountModifier;
					}
					return null;
				}

				public float? GetScrapValueModifier()
				{
					if (Config == null)
					{
						return null;
					}
					if (Config.OverrideScrapValueModifier)
					{
						return Config.ScrapValueModifier;
					}
					return null;
				}

				public int GetMinScrapAmount(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideMinScrapAmount)
					{
						return Config.MinScrapAmount;
					}
					return found;
				}

				public int GetMaxScrapAmount(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideMaxScrapAmount)
					{
						return Config.MaxScrapAmount;
					}
					return found;
				}

				public float GetDungeonSize(float found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideDungeonSize)
					{
						return Config.DungeonSize;
					}
					return found;
				}

				public int GetPrice(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverridePrice)
					{
						return Config.Price;
					}
					return found;
				}

				public int GetDaytimeEnemiesMaxPower(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideDaytimeEnemiesMaxPower)
					{
						return Config.DaytimeEnemiesMaxPower;
					}
					return found;
				}

				public int GetOutsideEnemiesMaxPower(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideOutsideEnemiesMaxPower)
					{
						return Config.OutsideEnemiesMaxPower;
					}
					return found;
				}

				public int GetInsideEnemiesMaxPower(int found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideInsideEnemiesMaxPower)
					{
						return Config.InsideEnemiesMaxPower;
					}
					return found;
				}

				public float GetDaytimeEnemiesProbabilityRange(float found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideDaytimeEnemiesProbability)
					{
						return Config.DaytimeEnemiesProbability;
					}
					return found;
				}

				public float GetInsideEnemiesProbabilityRange(float found)
				{
					if (Config == null)
					{
						return found;
					}
					if (Config.OverrideInsideEnemiesProbability)
					{
						return Config.InsideEnemiesProbability;
					}
					return found;
				}

				public List<SpawnableItemWithRarity> GetLootTable(List<SpawnableItemWithRarity> found)
				{
					//IL_0192: Unknown result type (might be due to invalid IL or missing references)
					//IL_0197: Unknown result type (might be due to invalid IL or missing references)
					//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b1: Expected O, but got Unknown
					//IL_0214: Unknown result type (might be due to invalid IL or missing references)
					//IL_0219: Unknown result type (might be due to invalid IL or missing references)
					//IL_0230: Unknown result type (might be due to invalid IL or missing references)
					//IL_023d: Expected O, but got Unknown
					if (Config == null)
					{
						return found;
					}
					if (_CurrentLoot == null)
					{
						List<SpawnableItemWithRarity> list = found.ToList();
						if (_OverrideLoot == null)
						{
							_OverrideLoot = new Dictionary<string, int>();
							foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig.LootTableItem> item in Config.LootTable)
							{
								if (Items.ScrapItemsByName.ContainsKey(item.Key))
								{
									if (!Items.IsSpawnable(Items.ScrapItemsByName[item.Key]))
									{
										_OverrideLoot.Add(item.Key, 0);
									}
									else if (item.Value.Override)
									{
										_OverrideLoot.Add(item.Key, item.Value.Rarity);
									}
								}
							}
						}
						HashSet<string> hashSet = new HashSet<string>();
						for (int i = 0; i < list.Count; i++)
						{
							SpawnableItemWithRarity val = list[i];
							hashSet.Add(val.spawnableItem.itemName);
							if (_OverrideLoot.ContainsKey(val.spawnableItem.itemName))
							{
								int num = _OverrideLoot[val.spawnableItem.itemName];
								if (num == 0)
								{
									list.RemoveAt(i);
									i--;
								}
								else
								{
									list[i] = new SpawnableItemWithRarity
									{
										spawnableItem = val.spawnableItem,
										rarity = num
									};
								}
							}
						}
						foreach (KeyValuePair<string, int> item2 in _OverrideLoot)
						{
							if (!hashSet.Contains(item2.Key))
							{
								int value = item2.Value;
								if (value > 0)
								{
									list.Add(new SpawnableItemWithRarity
									{
										spawnableItem = Items.ScrapItemsByName[item2.Key],
										rarity = value
									});
								}
							}
						}
						_CurrentLoot = list;
					}
					return _CurrentLoot;
				}

				public List<SpawnableEnemyWithRarity> GetDaytimeEnemies(List<SpawnableEnemyWithRarity> found)
				{
					//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d2: Expected O, but got Unknown
					//IL_0235: Unknown result type (might be due to invalid IL or missing references)
					//IL_023a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0256: Unknown result type (might be due to invalid IL or missing references)
					//IL_0263: Expected O, but got Unknown
					if (Config == null)
					{
						return found;
					}
					if (_CurrentDaytimeEnemies == null)
					{
						List<SpawnableEnemyWithRarity> list = found.ToList();
						if (_OverrideDaytimeEnemies == null)
						{
							_OverrideDaytimeEnemies = new Dictionary<string, int>();
							foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig.EnemyTableItem> daytimeEnemy in Config.DaytimeEnemies)
							{
								if (Enemies.EnemiesByName.ContainsKey(daytimeEnemy.Key) && Enemies.EnemiesByName.ContainsKey(daytimeEnemy.Key))
								{
									if (!Enemies.IsSpawnable(Enemies.EnemiesByName[daytimeEnemy.Key].EnemyType))
									{
										_OverrideDaytimeEnemies.Add(daytimeEnemy.Key, 0);
									}
									else if (daytimeEnemy.Value.Override)
									{
										_OverrideDaytimeEnemies.Add(daytimeEnemy.Key, daytimeEnemy.Value.Rarity);
									}
								}
							}
						}
						HashSet<string> hashSet = new HashSet<string>();
						for (int i = 0; i < list.Count; i++)
						{
							SpawnableEnemyWithRarity val = list[i];
							hashSet.Add(val.enemyType.enemyName);
							if (_OverrideDaytimeEnemies.ContainsKey(val.enemyType.enemyName))
							{
								int num = _OverrideDaytimeEnemies[val.enemyType.enemyName];
								if (num == 0)
								{
									list.RemoveAt(i);
									i--;
								}
								else
								{
									list[i] = new SpawnableEnemyWithRarity
									{
										enemyType = val.enemyType,
										rarity = num
									};
								}
							}
						}
						foreach (KeyValuePair<string, int> overrideDaytimeEnemy in _OverrideDaytimeEnemies)
						{
							if (!hashSet.Contains(overrideDaytimeEnemy.Key))
							{
								int value = overrideDaytimeEnemy.Value;
								if (value > 0)
								{
									list.Add(new SpawnableEnemyWithRarity
									{
										enemyType = Enemies.EnemiesByName[overrideDaytimeEnemy.Key].EnemyType,
										rarity = value
									});
								}
							}
						}
						_CurrentDaytimeEnemies = list;
					}
					return _CurrentDaytimeEnemies;
				}

				public List<SpawnableEnemyWithRarity> GetOutsideEnemies(List<SpawnableEnemyWithRarity> found)
				{
					//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d2: Expected O, but got Unknown
					//IL_0235: Unknown result type (might be due to invalid IL or missing references)
					//IL_023a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0256: Unknown result type (might be due to invalid IL or missing references)
					//IL_0263: Expected O, but got Unknown
					if (Config == null)
					{
						return found;
					}
					if (_CurrentOutsideEnemies == null)
					{
						List<SpawnableEnemyWithRarity> list = found.ToList();
						if (_OverrideOutsideEnemies == null)
						{
							_OverrideOutsideEnemies = new Dictionary<string, int>();
							foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig.EnemyTableItem> outsideEnemy in Config.OutsideEnemies)
							{
								if (Enemies.EnemiesByName.ContainsKey(outsideEnemy.Key))
								{
									if (!Enemies.IsSpawnable(Enemies.EnemiesByName[outsideEnemy.Key].EnemyType))
									{
										_OverrideOutsideEnemies.Add(outsideEnemy.Key, 0);
									}
									else if (Enemies.EnemiesByName.ContainsKey(outsideEnemy.Key) && outsideEnemy.Value.Override)
									{
										_OverrideOutsideEnemies.Add(outsideEnemy.Key, outsideEnemy.Value.Rarity);
									}
								}
							}
						}
						HashSet<string> hashSet = new HashSet<string>();
						for (int i = 0; i < list.Count; i++)
						{
							SpawnableEnemyWithRarity val = list[i];
							hashSet.Add(val.enemyType.enemyName);
							if (_OverrideOutsideEnemies.ContainsKey(val.enemyType.enemyName))
							{
								int num = _OverrideOutsideEnemies[val.enemyType.enemyName];
								if (num == 0)
								{
									list.RemoveAt(i);
									i--;
								}
								else
								{
									list[i] = new SpawnableEnemyWithRarity
									{
										enemyType = val.enemyType,
										rarity = num
									};
								}
							}
						}
						foreach (KeyValuePair<string, int> overrideOutsideEnemy in _OverrideOutsideEnemies)
						{
							if (!hashSet.Contains(overrideOutsideEnemy.Key))
							{
								int value = overrideOutsideEnemy.Value;
								if (value > 0)
								{
									list.Add(new SpawnableEnemyWithRarity
									{
										enemyType = Enemies.EnemiesByName[overrideOutsideEnemy.Key].EnemyType,
										rarity = value
									});
								}
							}
						}
						_CurrentOutsideEnemies = list;
					}
					return _CurrentOutsideEnemies;
				}

				public List<SpawnableEnemyWithRarity> GetInsideEnemies(List<SpawnableEnemyWithRarity> found)
				{
					//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d2: Expected O, but got Unknown
					//IL_0235: Unknown result type (might be due to invalid IL or missing references)
					//IL_023a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0256: Unknown result type (might be due to invalid IL or missing references)
					//IL_0263: Expected O, but got Unknown
					if (Config == null)
					{
						return found;
					}
					if (_CurrentInsideEnemies == null)
					{
						List<SpawnableEnemyWithRarity> list = found.ToList();
						if (_OverrideInsideEnemies == null)
						{
							_OverrideInsideEnemies = new Dictionary<string, int>();
							foreach (KeyValuePair<string, LobbyConfiguration.MoonConfig.EnemyTableItem> insideEnemy in Config.InsideEnemies)
							{
								if (Enemies.EnemiesByName.ContainsKey(insideEnemy.Key))
								{
									if (!Enemies.IsSpawnable(Enemies.EnemiesByName[insideEnemy.Key].EnemyType))
									{
										_OverrideInsideEnemies.Add(insideEnemy.Key, 0);
									}
									else if (Enemies.EnemiesByName.ContainsKey(insideEnemy.Key) && insideEnemy.Value.Override)
									{
										_OverrideInsideEnemies.Add(insideEnemy.Key, insideEnemy.Value.Rarity);
									}
								}
							}
						}
						HashSet<string> hashSet = new HashSet<string>();
						for (int i = 0; i < list.Count; i++)
						{
							SpawnableEnemyWithRarity val = list[i];
							hashSet.Add(val.enemyType.enemyName);
							if (_OverrideInsideEnemies.ContainsKey(val.enemyType.enemyName))
							{
								int num = _OverrideInsideEnemies[val.enemyType.enemyName];
								if (num == 0)
								{
									list.RemoveAt(i);
									i--;
								}
								else
								{
									list[i] = new SpawnableEnemyWithRarity
									{
										enemyType = val.enemyType,
										rarity = num
									};
								}
							}
						}
						foreach (KeyValuePair<string, int> overrideInsideEnemy in _OverrideInsideEnemies)
						{
							if (!hashSet.Contains(overrideInsideEnemy.Key))
							{
								int value = overrideInsideEnemy.Value;
								if (value > 0)
								{
									list.Add(new SpawnableEnemyWithRarity
									{
										enemyType = Enemies.EnemiesByName[overrideInsideEnemy.Key].EnemyType,
										rarity = value
									});
								}
							}
						}
						_CurrentInsideEnemies = list;
					}
					return _CurrentInsideEnemies;
				}
			}

			private static Dictionary<string, int> NewPrices = null;

			private static Dictionary<string, int> OriginalPrices = new Dictionary<string, int>();

			private static List<Moon> AllMoons = new List<Moon>();

			private static Dictionary<string, Moon> MoonsByName = new Dictionary<string, Moon>();

			public static void Reset()
			{
				NewPrices = null;
			}

			internal static void SearchMoons()
			{
				AllMoons = new List<Moon>();
				MoonsByName = new Dictionary<string, Moon>();
				OriginalPrices = new Dictionary<string, int>();
				Plugin.Log.LogMessage((object)"Searching for all moons...");
				TerminalKeyword val = Terminal.terminalNodes.allKeywords.First((TerminalKeyword keyword) => ((Object)keyword).name == "Route");
				CompatibleNoun[] compatibleNouns = val.compatibleNouns;
				foreach (CompatibleNoun val2 in compatibleNouns)
				{
					CompatibleNoun val3 = val2.result.terminalOptions.First((CompatibleNoun option) => ((Object)option.noun).name == "Confirm");
					if (val3.result.buyRerouteToMoon < StartOfRound.Instance.levels.Length)
					{
						string planetName = StartOfRound.Instance.levels[val3.result.buyRerouteToMoon].PlanetName;
						if (!OriginalPrices.ContainsKey(planetName))
						{
							Plugin.Log.LogDebug((object)("Found price " + val2.result.itemCost + " for moon " + planetName));
							OriginalPrices.Add(planetName, val2.result.itemCost);
						}
					}
				}
				HashSet<string> hashSet = new HashSet<string>();
				for (int j = 0; j < StartOfRound.Instance.levels.Length; j++)
				{
					SelectableLevel val4 = StartOfRound.Instance.levels[j];
					if (!MoonsByName.ContainsKey(val4.PlanetName))
					{
						Moon moon = new Moon
						{
							Level = val4,
							Config = (ServerConfiguration.Instance.Moons.Moons.ContainsKey(val4.PlanetName) ? ServerConfiguration.Instance.Moons.Moons[val4.PlanetName] : null)
						};
						AllMoons.Add(moon);
						MoonsByName.Add(val4.PlanetName, moon);
					}
				}
				Plugin.Log.LogDebug((object)("Found moons: " + string.Join(", ", MoonsByName.Keys)));
				AllMoons = AllMoons.OrderBy((Moon a) => a.Level.PlanetName).ToList();
				LobbyConfiguration.AllMoonsConfig.Moons.Clear();
				foreach (Moon allMoon in AllMoons)
				{
					Dictionary<string, LobbyConfiguration.MoonConfig.LootTableItem> dictionary = new Dictionary<string, LobbyConfiguration.MoonConfig.LootTableItem>();
					foreach (SpawnableItemWithRarity item in allMoon.Level.spawnableScrap)
					{
						if (!dictionary.ContainsKey(item.spawnableItem.itemName))
						{
							dictionary.Add(item.spawnableItem.itemName, new LobbyConfiguration.MoonConfig.LootTableItem
							{
								Override = false,
								Rarity = item.rarity
							});
						}
						else
						{
							dictionary[item.spawnableItem.itemName].Rarity += item.rarity;
							Plugin.Log.LogWarning((object)("Double loot table entry: " + item.spawnableItem.itemName));
						}
					}
					Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem> dictionary2 = new Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem>();
					foreach (SpawnableEnemyWithRarity daytimeEnemy in allMoon.Level.DaytimeEnemies)
					{
						if (!dictionary2.ContainsKey(daytimeEnemy.enemyType.enemyName))
						{
							dictionary2.Add(daytimeEnemy.enemyType.enemyName, new LobbyConfiguration.MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = daytimeEnemy.rarity
							});
						}
						else
						{
							dictionary2[daytimeEnemy.enemyType.enemyName].Rarity += daytimeEnemy.rarity;
							Plugin.Log.LogWarning((object)("Duplicate in inside enemies of moon \"" + allMoon.Level.PlanetName + "\" found: " + daytimeEnemy.enemyType.enemyName));
						}
					}
					Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem> dictionary3 = new Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem>();
					foreach (SpawnableEnemyWithRarity outsideEnemy in allMoon.Level.OutsideEnemies)
					{
						if (!dictionary3.ContainsKey(outsideEnemy.enemyType.enemyName))
						{
							dictionary3.Add(outsideEnemy.enemyType.enemyName, new LobbyConfiguration.MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = outsideEnemy.rarity
							});
						}
						else
						{
							dictionary3[outsideEnemy.enemyType.enemyName].Rarity += outsideEnemy.rarity;
							Plugin.Log.LogWarning((object)("Duplicate in outside enemies of moon \"" + allMoon.Level.PlanetName + "\" found: " + outsideEnemy.enemyType.enemyName));
						}
					}
					Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem> dictionary4 = new Dictionary<string, LobbyConfiguration.MoonConfig.EnemyTableItem>();
					foreach (SpawnableEnemyWithRarity enemy in allMoon.Level.Enemies)
					{
						if (!dictionary4.ContainsKey(enemy.enemyType.enemyName))
						{
							dictionary4.Add(enemy.enemyType.enemyName, new LobbyConfiguration.MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = enemy.rarity
							});
						}
						else
						{
							dictionary4[enemy.enemyType.enemyName].Rarity += enemy.rarity;
							Plugin.Log.LogWarning((object)("Duplicate in inside enemies of moon \"" + allMoon.Level.PlanetName + "\" found: " + enemy.enemyType.enemyName));
						}
					}
					LobbyConfiguration.AllMoonsConfig.Moons.Add(allMoon.Level.PlanetName, new LobbyConfiguration.MoonConfig
					{
						ScrapValueModifier = 1f,
						ScrapAmountModifier = 1f,
						DaytimeEnemiesMaxPower = allMoon.Level.maxDaytimeEnemyPowerCount,
						InsideEnemiesMaxPower = allMoon.Level.maxEnemyPowerCount,
						OutsideEnemiesMaxPower = allMoon.Level.maxOutsideEnemyPowerCount,
						DaytimeEnemiesProbability = allMoon.Level.daytimeEnemiesProbabilityRange,
						InsideEnemiesProbability = allMoon.Level.spawnProbabilityRange,
						DungeonSize = allMoon.Level.factorySizeMultiplier,
						MaxScrapAmount = allMoon.Level.maxScrap,
						MinScrapAmount = allMoon.Level.minScrap,
						Price = OriginalPrices[allMoon.Level.PlanetName],
						DaytimeEnemies = dictionary2,
						InsideEnemies = dictionary4,
						OutsideEnemies = dictionary3,
						LootTable = dictionary
					});
				}
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "advancedcompany", "moons.json"), ((JToken)LobbyConfiguration.AllMoonsConfig.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>()));
			}

			private static void Initialize()
			{
				if (NewPrices == null)
				{
					NewPrices = new Dictionary<string, int>();
				}
			}

			public static List<SpawnableEnemyWithRarity> GetDaytimeEnemies(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetDaytimeEnemies(level.DaytimeEnemies);
				}
				return level.DaytimeEnemies;
			}

			public static List<SpawnableEnemyWithRarity> GetOutsideEnemies(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetOutsideEnemies(level.OutsideEnemies);
				}
				return level.OutsideEnemies;
			}

			public static List<SpawnableEnemyWithRarity> GetInsideEnemies(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetInsideEnemies(level.Enemies);
				}
				return level.Enemies;
			}

			public static List<SpawnableItemWithRarity> GetLootTable(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetLootTable(level.spawnableScrap);
				}
				return level.spawnableScrap;
			}

			public static float GetDungeonSize(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetDungeonSize(level.factorySizeMultiplier);
				}
				return level.factorySizeMultiplier;
			}

			public static float GetScrapValueModifierOnly(RoundManager roundManager)
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Invalid comparison between Unknown and I4
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Invalid comparison between Unknown and I4
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Invalid comparison between Unknown and I4
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Invalid comparison between Unknown and I4
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Invalid comparison between Unknown and I4
				float num = 1f;
				if (MoonsByName.ContainsKey(roundManager.currentLevel.PlanetName))
				{
					float? scrapValueModifier = MoonsByName[roundManager.currentLevel.PlanetName].GetScrapValueModifier();
					if (scrapValueModifier.HasValue)
					{
						num *= scrapValueModifier.Value;
					}
				}
				if ((int)roundManager.currentLevel.currentWeather == 1 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.RainyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 3 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FoggyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 4 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FloodedWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 2 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.StormyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 5 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.EclipsedWeather.ScrapValueMultiplier;
				}
				else if (ServerConfiguration.Instance.Moons.ClearWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.ClearWeather.ScrapValueMultiplier;
				}
				return num * ServerConfiguration.Instance.General.GlobalScrapValueMultiplier;
			}

			public static float GetScrapValueModifier(RoundManager roundManager)
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Invalid comparison between Unknown and I4
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Invalid comparison between Unknown and I4
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Invalid comparison between Unknown and I4
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Invalid comparison between Unknown and I4
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Invalid comparison between Unknown and I4
				float num = roundManager.scrapValueMultiplier;
				if (MoonsByName.ContainsKey(roundManager.currentLevel.PlanetName))
				{
					float? scrapValueModifier = MoonsByName[roundManager.currentLevel.PlanetName].GetScrapValueModifier();
					if (scrapValueModifier.HasValue)
					{
						num *= scrapValueModifier.Value;
					}
				}
				if ((int)roundManager.currentLevel.currentWeather == 1 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.RainyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 3 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FoggyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 4 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FloodedWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 2 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.StormyWeather.ScrapValueMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 5 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.EclipsedWeather.ScrapValueMultiplier;
				}
				else if (ServerConfiguration.Instance.Moons.ClearWeather.OverrideScrapValueMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.ClearWeather.ScrapValueMultiplier;
				}
				return num * ServerConfiguration.Instance.General.GlobalScrapValueMultiplier;
			}

			public static float GetScrapAmountModifier(RoundManager roundManager)
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Invalid comparison between Unknown and I4
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Invalid comparison between Unknown and I4
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Invalid comparison between Unknown and I4
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Invalid comparison between Unknown and I4
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Invalid comparison between Unknown and I4
				float num = roundManager.scrapAmountMultiplier;
				if (MoonsByName.ContainsKey(roundManager.currentLevel.PlanetName))
				{
					float? scrapAmountModifier = MoonsByName[roundManager.currentLevel.PlanetName].GetScrapAmountModifier();
					if (scrapAmountModifier.HasValue)
					{
						num *= scrapAmountModifier.Value;
					}
				}
				if ((int)roundManager.currentLevel.currentWeather == 1 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.RainyWeather.ScrapAmountMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 3 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FoggyWeather.ScrapAmountMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 4 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.FloodedWeather.ScrapAmountMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 2 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.StormyWeather.ScrapAmountMultiplier;
				}
				else if ((int)roundManager.currentLevel.currentWeather == 5 && ServerConfiguration.Instance.Moons.RainyWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.EclipsedWeather.ScrapAmountMultiplier;
				}
				else if (ServerConfiguration.Instance.Moons.ClearWeather.OverrideScrapAmountMultiplier)
				{
					num *= ServerConfiguration.Instance.Moons.ClearWeather.ScrapAmountMultiplier;
				}
				return num * ServerConfiguration.Instance.General.GlobalScrapAmountMultiplier;
			}

			public static int GetMaxScrapAmount(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetMaxScrapAmount(level.maxScrap);
				}
				return level.maxScrap;
			}

			public static int GetMinScrapAmount(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetMinScrapAmount(level.minScrap);
				}
				return level.minScrap;
			}

			public static int GetDaytimeEnemiesMaxPower(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetDaytimeEnemiesMaxPower(level.maxDaytimeEnemyPowerCount);
				}
				return (int)((float)level.maxDaytimeEnemyPowerCount * ServerConfiguration.Instance.General.GlobalMaxPowerMultiplier);
			}

			public static int GetOutsideEnemiesMaxPower(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetOutsideEnemiesMaxPower(level.maxOutsideEnemyPowerCount);
				}
				return (int)((float)level.maxOutsideEnemyPowerCount * ServerConfiguration.Instance.General.GlobalMaxPowerMultiplier);
			}

			public static int GetInsideEnemiesMaxPower(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetInsideEnemiesMaxPower(level.maxEnemyPowerCount);
				}
				return (int)((float)level.maxEnemyPowerCount * ServerConfiguration.Instance.General.GlobalMaxPowerMultiplier);
			}

			public static float GetDaytimeEnemiesProbability(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetDaytimeEnemiesProbabilityRange(level.daytimeEnemiesProbabilityRange);
				}
				return level.daytimeEnemiesProbabilityRange;
			}

			public static float GetInsideEnemiesProbability(SelectableLevel level)
			{
				if (MoonsByName.ContainsKey(level.PlanetName))
				{
					return MoonsByName[level.PlanetName].GetInsideEnemiesProbabilityRange(level.spawnProbabilityRange);
				}
				return level.spawnProbabilityRange;
			}

			public static int GetMoonPrice(int moon, int defaultPrice = 0)
			{
				if (StartOfRound.Instance.levels.Length > moon)
				{
					string planetName = StartOfRound.Instance.levels[moon].PlanetName;
					if (MoonsByName.ContainsKey(planetName))
					{
						return MoonsByName[planetName].GetPrice(defaultPrice);
					}
				}
				return defaultPrice;
			}
		}

		internal class Save
		{
			public static void SaveItemsInShip(GrabbableObject[] objs)
			{
				Plugin.Log.LogInfo((object)"Saving ship data...");
				List<string> list = new List<string>();
				for (int i = 0; i < objs.Length && i <= StartOfRound.Instance.maxShipItemCapacity; i++)
				{
					if (StartOfRound.Instance.allItemsList.itemsList.Contains(objs[i].itemProperties) && !objs[i].deactivated && (Object)(object)objs[i].itemProperties.spawnPrefab != (Object)null && !objs[i].itemUsedUp)
					{
						string text = objs[i].itemProperties.itemId + "-" + objs[i].itemProperties.itemName;
						Plugin.Log.LogInfo((object)("Saving " + text));
						list.Add(text);
					}
				}
				ES3.Save<string[]>("shipGrabbableItemNames", list.ToArray(), GameNetworkManager.Instance.currentSaveFileName);
			}

			public static int[] LoadItemsInShip(int[] objs)
			{
				Plugin.Log.LogInfo((object)"Loading savegame data...");
				if (ES3.KeyExists("shipGrabbableItemNames", GameNetworkManager.Instance.currentSaveFileName))
				{
					Plugin.Log.LogDebug((object)"Found shipGrabbableItemNames");
					string[] array = ES3.Load<string[]>("shipGrabbableItemNames", GameNetworkManager.Instance.currentSaveFileName);
					for (int i = 0; i < array.Length; i++)
					{
						int num = array[i].IndexOf("-");
						if (num <= -1)
						{
							continue;
						}
						int num2 = int.Parse(array[i].Substring(0, num));
						string text = array[i].Substring(num + 1);
						bool flag = false;
						for (int j = 0; j < StartOfRound.Instance.allItemsList.itemsList.Count; j++)
						{
							if (StartOfRound.Instance.allItemsList.itemsList[j].itemId == num2)
							{
								if (StartOfRound.Instance.allItemsList.itemsList[j].itemName == text)
								{
									Plugin.Log.LogDebug((object)("Found item " + num2 + "-" + text));
									flag = true;
									objs[i] = j;
									break;
								}
								Plugin.Log.LogWarning((object)("Found item only with ID " + num2 + " but name " + array[i] + " mismatched with name " + StartOfRound.Instance.allItemsList.itemsList[j].itemName + "!"));
								flag = true;
								objs[i] = j;
								break;
							}
						}
						if (!flag)
						{
							Plugin.Log.LogWarning((object)("Couldn't find item " + array[i] + ". Replacing it with question mark block!"));
							objs[i] = StartOfRound.Instance.allItemsList.itemsList.IndexOf(ItemProperties[9999]);
						}
					}
				}
				return objs;
			}
		}

		private static bool FirstTerminalFrame = true;

		public static Terminal Terminal;

		public static GameOver OnGameOver;

		public static GameStarted OnGameStarted;

		public static Dictionary<int, ItemData> AddedItems = new Dictionary<int, ItemData>();

		public static Dictionary<int, Item> ItemProperties = new Dictionary<int, Item>();

		public static Dictionary<int, ItemRuntimeData> RuntimeItems = new Dictionary<int, ItemRuntimeData>();

		internal static Dictionary<string, MethodInfo> Patches = new Dictionary<string, MethodInfo>
		{
			{
				"Item.weight",
				typeof(Items).GetMethod("GetItemWeight", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"Item.creditsWorth",
				typeof(Items).GetMethod("GetItemPriceTranspiler", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"Item.highestSalePercentage",
				typeof(Items).GetMethod("GetItemHighestSalePercentage", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"Item.maxValue",
				typeof(Items).GetMethod("GetItemMaxValue", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"Item.minValue",
				typeof(Items).GetMethod("GetItemMinValue", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"TerminalNode.itemCost",
				typeof(Manager).GetMethod("GetNodeCost", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.maxScrap",
				typeof(Moons).GetMethod("GetMaxScrapAmount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.minScrap",
				typeof(Moons).GetMethod("GetMinScrapAmount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.factorySizeMultiplier",
				typeof(Moons).GetMethod("GetDungeonSize", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.daytimeEnemiesProbabilityRange",
				typeof(Moons).GetMethod("GetDaytimeEnemiesProbability", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.spawnProbabilityRange",
				typeof(Moons).GetMethod("GetInsideEnemiesProbability", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.maxDaytimeEnemyPowerCount",
				typeof(Moons).GetMethod("GetDaytimeEnemiesMaxPower", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.maxOutsideEnemyPowerCount",
				typeof(Moons).GetMethod("GetOutsideEnemiesMaxPower", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.maxEnemyPowerCount",
				typeof(Moons).GetMethod("GetInsideEnemiesMaxPower", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.Enemies",
				typeof(Moons).GetMethod("GetInsideEnemies", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.OutsideEnemies",
				typeof(Moons).GetMethod("GetOutsideEnemies", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.DaytimeEnemies",
				typeof(Moons).GetMethod("GetDaytimeEnemies", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"SelectableLevel.spawnableScrap",
				typeof(Moons).GetMethod("GetLootTable", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"EnemyType.PowerLevel",
				typeof(Enemies).GetMethod("GetPowerLevel", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"RoundManager.scrapAmountMultiplier",
				typeof(Moons).GetMethod("GetScrapAmountModifier", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			},
			{
				"RoundManager.scrapValueMultiplier",
				typeof(Moons).GetMethod("GetScrapValueModifier", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
			}
		};

		public static void Boot()
		{
			AdvancedCompany.Network.Manager.AddListener(delegate(AttractAllEnemies msg)
			{
				foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
				{
					if (spawnedEnemy.isOutside == msg.Inside && ((NetworkBehaviour)spawnedEnemy).IsOwner)
					{
						spawnedEnemy.StopSearch(spawnedEnemy.currentSearch, true);
						spawnedEnemy.movingTowardsTargetPlayer = true;
						spawnedEnemy.targetPlayer = StartOfRound.Instance.allPlayerScripts[msg.PlayerNum];
					}
				}
			});
		}

		public static void AddItem(GrabbableObject grabbableObject)
		{
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Expected O, but got Unknown
			grabbableObject.grabbable = true;
			grabbableObject.grabbableToEnemies = true;
			grabbableObject.useCooldown = 0.1f;
			GameObject gameObject = ((Component)grabbableObject).gameObject;
			gameObject.layer = 6;
			gameObject.tag = "PhysicsProp";
			ItemData component = gameObject.GetComponent<ItemData>();
			if ((Object)(object)component != (Object)null)
			{
				Shovel val = (Shovel)(object)((grabbableObject is Shovel) ? grabbableObject : null);
				if (val != null)
				{
					val.shovelAudio = ((Component)val).GetComponent<AudioSource>();
				}
				AddedItems.Add(component.ID, component);
				Item val2 = ScriptableObject.CreateInstance<Item>();
				val2.spawnPrefab = gameObject;
				((Object)val2).name = component.ItemName.Replace(" ", "");
				val2.itemName = component.ItemName;
				val2.itemId = component.ID;
				val2.itemIcon = component.ItemIcon;
				val2.creditsWorth = component.Price;
				val2.highestSalePercentage = component.MaxDiscount;
				val2.isConductiveMetal = component.IsConductive;
				val2.allowDroppingAheadOfPlayer = true;
				val2.twoHanded = component.IsTwoHanded;
				val2.syncUseFunction = component.SyncUseFunction;
				val2.syncInteractLRFunction = component.SyncInteractLRFunction;
				val2.syncGrabFunction = component.SyncGrabFunction;
				val2.syncDiscardFunction = component.SyncDiscardFunction;
				val2.restingRotation = component.GroundRestingRotation;
				val2.verticalOffset = component.GroundVerticalOffset;
				val2.weight = 1f + component.Weight / 105f;
				val2.saveItemVariable = component.HasSaveData;
				val2.isScrap = component.IsScrap;
				val2.dropSFX = component.DropSFX;
				val2.pocketSFX = component.PocketSFX;
				val2.grabSFX = component.GrabSFX;
				val2.requiresBattery = component.UsesBattery;
				val2.batteryUsage = component.BatteryUsage;
				if (val2.requiresBattery)
				{
					grabbableObject.insertedBattery = new Battery(false, 1f);
				}
				if (component.IsScrap)
				{
					val2.minValue = (int)((float)component.MinValue / 0.4f);
					val2.maxValue = (int)((float)component.MaxValue / 0.4f);
					GameObject val3 = new GameObject("ScanNode");
					val3.layer = 22;
					BoxCollider val4 = val3.AddComponent<BoxCollider>();
					ScanNodeProperties val5 = val3.AddComponent<ScanNodeProperties>();
					val5.minRange = 1;
					val5.maxRange = 13;
					val5.headerText = component.ItemName;
					val5.nodeType = 2;
					val5.creatureScanID = -1;
					val3.transform.parent = gameObject.transform;
					val3.transform.localPosition = Vector3.zero;
					GameAssets.Scrap.Add(val2.itemName, val2);
				}
				if (component.HoldAnimation != null)
				{
					if (component.HoldIsTwoHanded)
					{
						val2.twoHandedAnimation = true;
					}
					val2.grabAnim = component.HoldAnimation;
				}
				val2.meshVariants = (Mesh[])(object)new Mesh[0];
				val2.materialVariants = (Material[])(object)new Material[0];
				grabbableObject.itemProperties = val2;
				ItemProperties.Add(component.ID, val2);
				if (component.IsBuyable)
				{
					string text = val2.itemName.Replace(" ", "-");
					TerminalNode val6 = ScriptableObject.CreateInstance<TerminalNode>();
					((Object)val6).name = text + "BuyNode2";
					val6.displayText = "Ordered [variableAmount] " + val2.itemName + ". Your new balance is [playerCredits].\n\nOur contractors enjoy fast, free shipping while on the job! Any purchased items will arrive hourly at your approximate location.\r\n\r\n";
					val6.clearPreviousText = true;
					val6.maxCharactersToType = 35;
					val6.isConfirmationNode = false;
					val6.itemCost = val2.creditsWorth;
					val6.playSyncedClip = 0;
					TerminalNode val7 = ScriptableObject.CreateInstance<TerminalNode>();
					((Object)val7).name = text + "BuyNode1";
					val7.displayText = "You have requested to order " + val2.itemName + ". Amount: [variableAmount].\nTotal cost of items: [totalCost].\n\nPlease CONFIRM or DENY.\r\n\r\n";
					val7.clearPreviousText = true;
					val7.maxCharactersToType = 35;
					val7.isConfirmationNode = true;
					val7.overrideOptions = true;
					val7.itemCost = val2.creditsWorth;
					TerminalKeyword val8 = ScriptableObject.CreateInstance<TerminalKeyword>();
					val8.word = val2.itemName.Replace(" ", "").ToLowerInvariant();
					((Object)val8).name = val8.word + "Keyword";
					val8.isVerb = false;
					CompatibleNoun val9 = new CompatibleNoun();
					val9.noun = val8;
					val9.result = val7;
					RuntimeItems.Add(component.ID, new ItemRuntimeData
					{
						Item = val2,
						BuyCompletedNode = val6,
						BuyConfirmationNode = val7,
						Keyword = val8,
						Noun = val9
					});
				}
				Utils.AddNetworkPrefab(gameObject);
			}
			else
			{
				Plugin.Log.LogError((object)("ItemData was missing on " + ((Object)gameObject).name));
			}
		}

		[HarmonyPatch(typeof(Terminal), "Update")]
		[HarmonyPostfix]
		private static void Update(Terminal __instance)
		{
			if (FirstTerminalFrame)
			{
				FirstTerminalFrame = false;
				Items.SearchItems();
				Moons.SearchMoons();
				Enemies.SearchEnemies();
			}
		}

		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPostfix]
		private static void SetTimeAndPlanetToSavedSettings(Terminal __instance)
		{
			if (StartOfRound.Instance.gameStats.daysSpent == 0)
			{
				Plugin.Log.LogMessage((object)("Terminal starting credits to: " + ServerConfiguration.Instance.General.StartCredits));
				__instance.groupCredits = ServerConfiguration.Instance.General.StartCredits;
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SetTimeAndPlanetToSavedSettings")]
		[HarmonyPostfix]
		private static void SetTimeAndPlanetToSavedSettings(StartOfRound __instance)
		{
			if ((Object)(object)Terminal == (Object)null)
			{
				Terminal = Object.FindObjectOfType<Terminal>();
			}
			if (__instance.gameStats.daysSpent == 0)
			{
				if ((Object)(object)Terminal != (Object)null)
				{
					Plugin.Log.LogMessage((object)("Set starting credits to: " + ServerConfiguration.Instance.General.StartCredits));
					Terminal.groupCredits = ServerConfiguration.Instance.General.StartCredits;
				}
				TimeOfDay.Instance.timeUntilDeadline = (int)(TimeOfDay.Instance.totalTime * GetDeadlineDays());
				TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
		[HarmonyPostfix]
		private static void ResetShip(StartOfRound __instance)
		{
			if ((Object)(object)Terminal == (Object)null)
			{
				Terminal = Object.FindObjectOfType<Terminal>();
			}
			if ((Object)(object)Terminal != (Object)null)
			{
				Terminal.groupCredits = ServerConfiguration.Instance.General.StartCredits;
			}
			TimeOfDay.Instance.timeUntilDeadline = (int)(TimeOfDay.Instance.totalTime * GetDeadlineDays());
			TimeOfDay.Instance.UpdateProfitQuotaCurrentTime();
			TimeOfDay.Instance.OnDayChanged();
		}

		public static float GetDeadlineDays()
		{
			return (float)ServerConfiguration.Instance.General.DeadlineLength * 1f;
		}

		public static void GrantXP()
		{
			if (NetworkManager.Singleton.IsServer)
			{
				int num = TimeOfDay.Instance.profitQuota;
				if (!ServerConfiguration.Instance.General.SaveProgress)
				{
					num = (int)((float)num * ServerConfiguration.Instance.General.XPMultiplier);
				}
				AdvancedCompany.Network.Manager.Send(new GrantPlayerXP
				{
					All = true,
					XP = num
				}, 0uL);
				AdvancedCompany.Network.Manager.Send(new GrantShipXP
				{
					XP = num
				}, 0uL);
				AdvancedCompany.Network.Manager.Send(new ChangeShip
				{
					TotalQuota = AdvancedCompany.Network.Manager.Lobby.CurrentShip.TotalQuota + TimeOfDay.Instance.profitQuota,
					ExtendedDeadline = false
				}, 0uL);
			}
		}

		[HarmonyPatch(typeof(TimeOfDay), "SetNewProfitQuota")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSetNewProfitQuota(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching TimeOfDay->SetNewProfitQuota...");
			MethodInfo method = typeof(Manager).GetMethod("GetDeadlineDays", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			MethodInfo method2 = typeof(Manager).GetMethod("GrantXP", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldc_R4 && list[i].operand is float num && num == 4f)
				{
					Plugin.Log.LogDebug((object)"Changed 4f to Manager->GetDeadlineDays()");
					list[i].opcode = OpCodes.Call;
					list[i].operand = method;
					break;
				}
			}
			list.Insert(0, new CodeInstruction(OpCodes.Call, (object)method2));
			Plugin.Log.LogDebug((object)"Patched TimeOfDay->SetNewProfitQuota...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(TimeOfDay), "SyncNewProfitQuotaClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchSyncNewProfitQuotaClientRpc(IEnumerable<CodeInstruction> instructions)
		{
			Plugin.Log.LogDebug((object)"Patching TimeOfDay->SyncNewProfitQuotaClientRpc...");
			MethodInfo method = typeof(Manager).GetMethod("GetDeadlineDays", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand.ToString().Contains("deadlineDaysAmount"))
				{
					list[i].opcode = OpCodes.Call;
					list[i].operand = method;
					list.RemoveAt(i + 1);
					list.RemoveAt(i - 2);
					list.RemoveAt(i - 2);
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched TimeOfDay->SyncNewProfitQuotaClientRpc...");
			return list.AsEnumerable();
		}

		public static void DeactivateShipDecor(List<TerminalNode> items)
		{
			for (int i = 0; i < items.Count; i++)
			{
				if (items[i].shipUnlockableID > -1 && StartOfRound.Instance.unlockablesList.unlockables.Count > items[i].shipUnlockableID)
				{
					UnlockableItem item = StartOfRound.Instance.unlockablesList.unlockables[items[i].shipUnlockableID];
					if (!Items.IsUnlockableBuyable(item))
					{
						items.RemoveAt(i);
						i--;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Terminal), "RotateShipDecorSelection")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PatchRotateShipDecorSelection(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			Plugin.Log.LogDebug((object)"Patching Terminal->RotateShipDecorSelection...");
			MethodInfo method = typeof(Manager).GetMethod("DeactivateShipDecor", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Call && list[i].operand.ToString().Contains("Next"))
				{
					list.Insert(i + 2, new CodeInstruction(OpCodes.Stloc_S, (object)4));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)method));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Ldloc_S, (object)4));
					break;
				}
			}
			Plugin.Log.LogDebug((object)"Patched Terminal->RotateShipDecorSelection...");
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(Terminal), "Awake")]
		[HarmonyPostfix]
		private static void TerminalAwake(Terminal __instance)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Moons.Reset();
			Terminal = __instance;
			FirstTerminalFrame = true;
			Plugin.Log.LogInfo((object)"Adding own items to Terminal.");
			TerminalKeyword val = ScriptableObject.CreateInstance<TerminalKeyword>();
			val.isVerb = false;
			val.word = "perks";
			val.specialKeywordResult = new TerminalNode
			{
				clearPreviousText = true,
				displayText = "To level up your character leave this terminal and get out your handy portable terminal (default key X).\n\nSponsored by <color=#ffffff>AdvancedTech</color>\n<color=#ff3333>Advancing mankind!</color>\n\n<size=60%>AdvancedTech is not responsible for any damages that may occur in connection with items sponsored by AdvancedTech for evaluation purposes. AdvancedTech reserves the right to take legal action against any statements to the contrary.</size>\n\n<size=100%>"
			};
			TerminalKeyword val2 = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "buy");
			List<TerminalKeyword> list = __instance.terminalNodes.allKeywords.ToList();
			List<CompatibleNoun> list2 = val2.compatibleNouns.ToList();
			List<Item> list3 = __instance.buyableItemsList.ToList();
			list.Add(val);
			TerminalNode result = val2.compatibleNouns[0].result.terminalOptions[1].result;
			TerminalKeyword val3 = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "info");
			TerminalKeyword confirmKeyword = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "confirm");
			TerminalKeyword denyKeyword = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "deny");
			foreach (KeyValuePair<int, Item> itemProperty in ItemProperties)
			{
				if (itemProperty.Value.itemName == "Vision enhancer")
				{
					itemProperty.Value.batteryUsage = ServerConfiguration.Instance.Items.VisionEnhancer.BatteryTime;
				}
				if (itemProperty.Value.itemName == "Helmet lamp")
				{
					itemProperty.Value.batteryUsage = ServerConfiguration.Instance.Items.HelmetLamp.BatteryTime;
				}
				if (itemProperty.Value.itemName == "Headset")
				{
					itemProperty.Value.batteryUsage = ServerConfiguration.Instance.Items.Headset.BatteryTime;
				}
				if (itemProperty.Value.itemName == "Tactical helmet")
				{
					itemProperty.Value.batteryUsage = ServerConfiguration.Instance.Items.TacticalHelmet.BatteryTime;
				}
				if (AddedItems[itemProperty.Key].IsBuyable)
				{
					Plugin.Log.LogInfo((object)("Adding " + AddedItems[itemProperty.Key].ItemName));
					ItemRuntimeData itemRuntimeData = RuntimeItems[itemProperty.Key];
					itemRuntimeData.Apply(val2, list, list2, result, confirmKeyword, denyKeyword, list3);
				}
			}
			__instance.buyableItemsList = list3.ToArray();
			val2.compatibleNouns = list2.ToArray();
			__instance.terminalNodes.allKeywords = list.ToArray();
		}

		public static int GetNodeCost(TerminalNode node)
		{
			if ((Object)(object)Terminal == (Object)null)
			{
				Terminal = Object.FindObjectOfType<Terminal>();
			}
			if ((Object)(object)Terminal == (Object)null)
			{
				return node.itemCost;
			}
			if (node.displayPlanetInfo > -1)
			{
				int num = (int)((float)Moons.GetMoonPrice(node.displayPlanetInfo, node.itemCost) * Perks.GetMultiplier("TravelDiscount"));
				if (num != -1)
				{
					return num;
				}
			}
			if (node.buyRerouteToMoon > -1)
			{
				int num2 = (int)((float)Moons.GetMoonPrice(node.buyRerouteToMoon, node.itemCost) * Perks.GetMultiplier("TravelDiscount"));
				if (num2 != -1)
				{
					return num2;
				}
			}
			if (node.buyItemIndex > -1 && Terminal.buyableItemsList.Length > node.buyItemIndex)
			{
				return Items.GetItemPrice(Terminal.buyableItemsList[node.buyItemIndex]);
			}
			if (node.shipUnlockableID > -1 && StartOfRound.Instance.unlockablesList.unlockables.Count > node.shipUnlockableID)
			{
				return Items.GetUnlockablePrice(StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID]);
			}
			return node.itemCost;
		}

		internal static bool CompareField(FieldInfo fieldInfo, string name)
		{
			string text = fieldInfo.DeclaringType.FullName + "." + fieldInfo.Name;
			return text == name;
		}

		internal static IEnumerable<CodeInstruction> PatchFields(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				foreach (KeyValuePair<string, MethodInfo> patch in Patches)
				{
					if (list[i].IsLdfld(patch.Key))
					{
						list[i].opcode = OpCodes.Call;
						list[i].operand = patch.Value;
						Plugin.Log.LogDebug((object)("Replaced " + patch.Key + " with " + patch.Value.DeclaringType.FullName + "->" + patch.Value.Name));
					}
				}
			}
			return list.AsEnumerable();
		}
	}
	[Bootable]
	[Requires(typeof(ClientConfiguration))]
	[LoadAssets]
	[HarmonyPatch]
	public class MobileTerminal
	{
		internal static GameObject TerminalPrefab;

		internal bool SkipUpdate;

		internal Coroutine HideMobileTerminalCoroutine;

		internal GameObject SpawnedInstance;

		internal Player Player;

		internal bool IsOpen;

		internal ScrollRect ScrollRect;

		internal TextMeshProUGUI Output;

		internal TMP_InputField Input;

		internal GameObject InputContainer;

		internal string Text = "";

		internal bool AddedLines = false;

		internal static InputAction MobileTerminalAction;

		internal IApplication RunningApplication;

		internal bool InputActivated = true;

		internal static IApplication StartApplication;

		internal static Regex ParametersRegex;

		internal static List<IFallbackApplication> FallbackApplications;

		internal static Dictionary<string, IApplication> Applications;

		internal static Dictionary<string, string> Links;

		internal const float SendKeyCooldown = 0.5f;

		internal const float KeyCooldown = 0.07f;

		internal float KeyTimer = 0f;

		internal float SendKeyTimer = 0f;

		internal float LastMobileTerminalSync = 0f;

		internal float LastScrollSync = 0f;

		internal string LastMobileTerminalSyncText = "";

		internal string LastMobileTerminalSyncInput = "";

		internal bool ScrollToTop = false;

		internal int ScrollTo = -1;

		internal MobileTerminal(Player player)
		{
			Player = player;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "OpenMenu_performed")]
		[HarmonyPrefix]
		internal static bool OpenMenu_performed(PlayerControllerB __instance, CallbackContext context)
		{
			if ((Object)(object)__instance == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				Player player = Player.GetPlayer(__instance);
				if (player.MobileTerminal.IsOpen && ((CallbackContext)(ref context)).performed)
				{
					player.MobileTerminal.Close();
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPrefix]
		internal static void Update(PlayerControllerB __instance)
		{
			Player player = Player.GetPlayer(__instance);
			if (player.IsLocal && player.MobileTerminal.IsOpen)
			{
				player.MobileTerminal.Update();
			}
		}

		public static void LoadAssets(AssetBundle assets)
		{
			TerminalPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Objects/MobileTerminal.prefab");
		}

		public static void Boot()
		{
			ClientConfiguration.Keybinds.PortableTerminal.performed += delegate
			{
				if ((Object)(object)StartOfRound.Instance != (Object)null && (Object)(object)StartOfRound.Instance.localPlayerController != (Object)null)
				{
					Player player2 = Player.GetPlayer(StartOfRound.Instance.localPlayerController);
					if (!player2.IsCrouching && !ShipBuildModeManager.Instance.InBuildMode && !player2.Controller.quickMenuManager.isMenuOpen && ((((NetworkBehaviour)player2.Controller).IsOwner && player2.Controller.isPlayerControlled && (!((NetworkBehaviour)player2.Controller).IsServer || player2.Controller.isHostPlayerObject)) || player2.Controller.isTestingPlayer) && !player2.Controller.inSpecialInteractAnimation && !player2.Controller.isTypingChat && (player2.Controller.isMovementHindered <= 0 || player2.Controller.isUnderwater) && (player2.Controller.thisController.isGrounded || (!player2.Controller.isJumping && player2.Controller.IsPlayerNearGround())) && !player2.Controller.isJumping && (!player2.Controller.isPlayerSliding || player2.Controller.playerSlidingTimer > 2.5f) && !player2.MobileTerminal.IsOpen)
					{
						player2.MobileTerminal.ToggleMobileTerminal();
					}
				}
			};
			AdvancedCompany.Network.Manager.AddListener(delegate(UseMobileTerminal msg)
			{
				Player player = Player.GetPlayer(msg.PlayerNum);
				if (player != null && !player.IsLocal)
				{
					if (msg.IsUsingTerminal)
					{
						player.MobileTerminal.Open();
						((TMP_Text)player.MobileTerminal.Output).text = msg.ConsoleText;
						player.MobileTerminal.Input.text = msg.InputText;
						((TMP_Text)player.MobileTerminal.Output).ForceMeshUpdate(false, false);
						LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)player.MobileTerminal.ScrollRect).GetComponent<RectTransform>());
						player.MobileTerminal.ScrollRect.verticalNormalizedPosition = msg.Scroll;
					}
					else
					{
						player.MobileTerminal.Close();
					}
				}
			});
		}

		internal void ToggleMobileTerminal()
		{
			if (ServerConfiguration.Instance.General.ActivatePortableTerminal)
			{
				if (IsOpen)
				{
					Close();
				}
				else
				{
					Open();
				}
			}
		}

		public void Submit(string input, string[] additionalParams = null)
		{
			Input.text = "";
			if (RunningApplication != null)
			{
				RunningApplication.Submit(input);
			}
			else
			{
				MatchCollection matchCollection = ParametersRegex.Matches(input);
				List<string> list = new List<string>();
				for (int i = 0; i < matchCollection.Count; i++)
				{
					if (matchCollection[i].Groups[2].Value != "")
					{
						list.Add(matchCollection[i].Groups[2].Value);
					}
					else if (matchCollection[i].Groups[3].Value != "")
					{
						list.Add(matchCollection[i].Groups[3].Value);
					}
					else
					{
						Plugin.Log.LogWarning((object)("A parameter wasn't parseable: " + matchCollection[i].Value));
					}
				}
				if (list.Count > 0)
				{
					string[] array = new string[list.Count - 1];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = list[j + 1];
					}
					if (Applications.ContainsKey(list[0]))
					{
						if (additionalParams != null)
						{
							string[] array2 = new string[array.Length + additionalParams.Length];
							Array.Copy(array, 0, array2, 0, array.Length);
							Array.Copy(additionalParams, 0, array2, array.Length, additionalParams.Length);
							array = array2;
						}
						Start(Applications[list[0]], array);
					}
					else if (Links.ContainsKey(list[0]))
					{
						Submit(Links[list[0]], array);
					}
					else
					{
						float num = 0f;
						IFallbackApplication fallbackApplication = null;
						foreach (IFallbackApplication fallbackApplication2 in FallbackApplications)
						{
							float num2 = fallbackApplication2.Certainty(input);
							if (num2 > num)
							{
								num = num2;
								fallbackApplication = fallbackApplication2;
							}
						}
						if (fallbackApplication != null && fallbackApplication is IApplication runningApplication)
						{
							RunningApplication = runningApplication;
							SkipUpdate = true;
							fallbackApplication.Fallback(this, input);
						}
						else
						{
							WriteLine("Command \"" + list[0] + "\" not found.");
						}
					}
				}
			}
			((MonoBehaviour)Player.Controller).StartCoroutine(SelectInput());
		}

		internal IEnumerator SelectInput()
		{
			yield return (object)new WaitForEndOfFrame();
			if (InputActivated)
			{
				((Selectable)Input).interactable = true;
				Input.ActivateInputField();
				((Selectable)Input).Select();
			}
			else
			{
				Input.DeactivateInputField(false);
				((Selectable)Input).interactable = false;
			}
		}

		static MobileTerminal()
		{
			ParametersRegex = new Regex("(?:(['\"])(.*?)(?<!\\\\)(?>\\\\\\\\)*\\1|([^\\s]+))");
			FallbackApplications = new List<IFallbackApplication>();
			Applications = new Dictionary<string, IApplication>(StringComparer.OrdinalIgnoreCase);
			Links = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			HelpApplication helpApplication = new HelpApplication();
			RegisterApplication("help", helpApplication);
			StartApplication = helpApplication;
		}

		public static void RegisterApplication(string applicationName, IApplication application)
		{
			if (!Applications.ContainsKey(applicationName))
			{
				Applications.Add(applicationName, application);
				if (application is IFallbackApplication item)
				{
					FallbackApplications.Add(item);
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)("An application with the name \"" + applicationName + "\" was already added!"));
			}
		}

		public static void RegisterLink(string linkName, string linkTo)
		{
			if (!Links.ContainsKey(linkName))
			{
				Links.Add(linkName, linkTo);
			}
			else
			{
				Plugin.Log.LogWarning((object)("A link with the name \"" + linkName + "\" was already added!"));
			}
		}

		public void Open()
		{
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen)
			{
				return;
			}
			IsOpen = true;
			if (Player.IsLocal)
			{
				Plugin.Log.LogDebug((object)("Player " + Player.PlayerNum + " (local) opening terminal"));
				Transform bone = Player.GetBone(Player.EgoBone.L_HAND);
				foreach (VolumeComponent component in HUDManager.Instance.playerGraphicsVolume.profile.components)
				{
					DepthOfField val = (DepthOfField)(object)((component is DepthOfField) ? component : null);
					if (val != null)
					{
						((VolumeParameter<float>)(object)val.nearFocusEnd).value = 0.1f;
					}
				}
				HUDManager.Instance.HideHUD(true);
				if ((Object)(object)SpawnedInstance == (Object)null)
				{
					SpawnedInstance = Object.Instantiate<GameObject>(TerminalPrefab, bone);
					SpawnedInstance.transform.localScale = new Vector3(0.126f, 0.126f, 0.126f);
					SpawnedInstance.transform.localPosition = new Vector3(-0.248f, 0.029f, -0.262f);
					SpawnedInstance.transform.localRotation = Quaternion.Euler(new Vector3(72.166f, -67.123f, -242.925f));
					ScrollRect = ((Component)SpawnedInstance.transform.Find("UI/Scroll View")).GetComponent<ScrollRect>();
					Transform val2 = ((Component)ScrollRect).transform.Find("Viewport/Content");
					Output = ((Component)val2.Find("Output")).GetComponent<TextMeshProUGUI>();
					InputContainer = ((Component)val2.Find("Input")).gameObject;
					Input = ((Component)InputContainer.transform.Find("InputField (TMP)")).GetComponent<TMP_InputField>();
					((UnityEvent<string>)(object)Input.onSubmit).AddListener((UnityAction<string>)delegate(string input)
					{
						Submit(input);
					});
				}
				else
				{
					SpawnedInstance.SetActive(true);
				}
				Player.Controller.playingQuickSpecialAnimation = true;
				Player.Controller.inSpecialInteractAnimation = true;
				Player.Controller.inTerminalMenu = true;
				Player.Controller.playerBodyAnimator.ResetTrigger("SA_stopAnimation");
				if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
				{
					Player.Controller.playerBodyAnimator.SetTrigger("SA_Typing");
				}
				else
				{
					Player.Controller.playerBodyAnimator.SetTrigger("MobileTerminal");
				}
				Clear();
				Start(StartApplication);
				Input.text = "";
				((Selectable)Input).interactable = true;
				((Selectable)Input).Select();
				AdvancedCompany.Network.Manager.Send(new UseMobileTerminal
				{
					PlayerNum = Player.PlayerNum,
					ConsoleText = Text,
					InputText = Input.text,
					Scroll = 1f,
					IsUsingTerminal = true
				}, 0uL);
				if ((Object)(object)Player.Controller.currentlyHeldObject != (Object)null)
				{
					Player.Controller.currentlyHeldObject.EnableItemMeshes(false);
				}
				if ((Object)(object)Player.Controller.currentlyHeldObjectServer != (Object)null)
				{
					Player.Controller.currentlyHeldObjectServer.EnableItemMeshes(false);
				}
			}
			else
			{
				Plugin.Log.LogDebug((object)("Player " + Player.PlayerNum + " opening terminal"));
				Transform bone2 = Player.GetBone(Player.Bone.L_HAND);
				if ((Object)(object)SpawnedInstance == (Object)null)
				{
					SpawnedInstance = Object.Instantiate<GameObject>(TerminalPrefab, bone2);
					SpawnedInstance.transform.localScale = new Vector3(0.126f, 0.126f, 0.126f);
					SpawnedInstance.transform.localPosition = new Vector3(-0.18f, 0.032f, -0.3f);
					SpawnedInstance.transform.localRotation = Quaternion.Euler(new Vector3(74.532f, -76.956f, -240.481f));
					ScrollRect = ((Component)SpawnedInstance.transform.Find("UI/Scroll View")).GetComponent<ScrollRect>();
					Transform val3 = ((Component)ScrollRect).transform.Find("Viewport/Content");
					Output = ((Component)val3.Find("Output")).GetComponent<TextMeshProUGUI>();
					Input = ((Component)val3.Find("Input/InputField (TMP)")).GetComponent<TMP_InputField>();
				}
				else
				{
					SpawnedInstance.SetActive(true);
				}
				Player.Controller.playingQuickSpecialAnimation = true;
				Player.Controller.inSpecialInteractAnimation = true;
				Player.Controller.inTerminalMenu = true;
				if ((Object)(object)Player.Controller.currentlyHeldObject != (Object)null)
				{
					Player.Controller.currentlyHeldObject.EnableItemMeshes(false);
				}
				if ((Object)(object)Player.Controller.currentlyHeldObjectServer != (Object)null)
				{
					Player.Controller.currentlyHeldObjectServer.EnableItemMeshes(false);
				}
			}
			if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				Player.AddOverride("TypeOnTerminal", "DrawMobileTerminal");
				Player.AddOverride("TypeOnTerminal2", "HoldMobileTerminal");
			}
		}

		public void Close()
		{
			if (!IsOpen)
			{
				return;
			}
			IsOpen = false;
			((Selectable)Input).interactable = false;
			if (Player.IsLocal)
			{
				InventoryPatches.ArrangeHotbar(Perks.InventorySlots());
				Plugin.Log.LogDebug((object)("Player " + Player.PlayerNum + " (local) closing terminal"));
				Player.Controller.playingQuickSpecialAnimation = false;
				Player.Controller.inSpecialInteractAnimation = false;
				Player.Controller.inTerminalMenu = false;
				if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
				{
					Player.Controller.playerBodyAnimator.ResetTrigger("SA_Typing");
				}
				else
				{
					Player.Controller.playerBodyAnimator.ResetTrigger("MobileTerminal");
				}
				Player.Controller.playerBodyAnimator.SetTrigger("SA_stopAnimation");
				if (HideMobileTerminalCoroutine != null)
				{
					((MonoBehaviour)Player.Controller).StopCoroutine(HideMobileTerminalCoroutine);
				}
				HideMobileTerminalCoroutine = ((MonoBehaviour)Player.Controller).StartCoroutine(HideTerminal());
				AdvancedCompany.Network.Manager.Send(new UseMobileTerminal
				{
					PlayerNum = Player.PlayerNum,
					IsUsingTerminal = false
				}, 0uL);
				if ((Object)(object)Player.Controller.currentlyHeldObject != (Object)null)
				{
					Player.Controller.currentlyHeldObject.EnableItemMeshes(true);
				}
				if ((Object)(object)Player.Controller.currentlyHeldObjectServer != (Object)null)
				{
					Player.Controller.currentlyHeldObjectServer.EnableItemMeshes(true);
				}
			}
			else
			{
				Plugin.Log.LogDebug((object)("Player " + Player.PlayerNum + " closing terminal"));
				Player.Controller.playingQuickSpecialAnimation = false;
				Player.Controller.inSpecialInteractAnimation = false;
				Player.Controller.inTerminalMenu = false;
				if (HideMobileTerminalCoroutine != null)
				{
					((MonoBehaviour)Player.Controller).StopCoroutine(HideMobileTerminalCoroutine);
				}
				HideMobileTerminalCoroutine = ((MonoBehaviour)Player.Controller).StartCoroutine(HideTerminal());
				if ((Object)(object)Player.Controller.currentlyHeldObject != (Object)null)
				{
					Player.Controller.currentlyHeldObject.EnableItemMeshes(true);
				}
				if ((Object)(object)Player.Controller.currentlyHeldObjectServer != (Object)null)
				{
					Player.Controller.currentlyHeldObjectServer.EnableItemMeshes(true);
				}
			}
		}

		internal IEnumerator HideTerminal()
		{
			yield return (object)new WaitForSeconds(0.2f);
			SpawnedInstance.SetActive(false);
			if (Player.IsLocal)
			{
				foreach (VolumeComponent vol in HUDManager.Instance.playerGraphicsVolume.profile.components)
				{
					DepthOfField dof = (DepthOfField)(object)((vol is DepthOfField) ? vol : null);
					if (dof != null)
					{
						((VolumeParameter<float>)(object)dof.nearFocusEnd).value = 0.5f;
					}
				}
				HUDManager.Instance.HideHUD(false);
			}
			if (Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				Player.RemoveOverride("TypeOnTerminal");
				Player.RemoveOverride("TypeOnTerminal2");
			}
		}

		public void Update()
		{
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			if (RunningApplication != null)
			{
				if (!SkipUpdate)
				{
					RunningApplication.Update();
				}
				SkipUpdate = false;
			}
			if (KeyTimer > 0f)
			{
				KeyTimer -= Time.deltaTime;
			}
			if (!Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
			{
				Player.Controller.playerBodyAnimator.ResetTrigger("MobileTerminalTyping");
			}
			if ((Object)(object)Manager.Terminal != (Object)null && ((ButtonControl)Keyboard.current.anyKey).wasPressedThisFrame)
			{
				if (!Plugin.UseAnimationOverride || ClientConfiguration.Instance.Compability.AnimationsCompability)
				{
					Player.Controller.playerBodyAnimator.SetTrigger("MobileTerminalTyping");
				}
				if (KeyTimer <= 0f)
				{
					KeyTimer = 0.07f;
					RoundManager.PlayRandomClip(Player.Controller.itemAudio, Manager.Terminal.keyboardClips, true, 1f, 0);
				}
			}
			if (LastMobileTerminalSync > 0f)
			{
				LastMobileTerminalSync -= Time.deltaTime;
			}
			if (LastMobileTerminalSync <= 0f && (LastMobileTerminalSyncText != Text || LastMobileTerminalSyncInput != Input.text || ScrollRect.verticalNormalizedPosition != LastScrollSync))
			{
				LastMobileTerminalSync = 1f;
				LastMobileTerminalSyncText = Text;
				LastMobileTerminalSyncInput = Input.text;
				LastScrollSync = ScrollRect.verticalNormalizedPosition;
				AdvancedCompany.Network.Manager.Send(new UseMobileTerminal
				{
					PlayerNum = Player.PlayerNum,
					IsUsingTerminal = true,
					ConsoleText = Text,
					InputText = Input.text,
					Scroll = ScrollRect.verticalNormalizedPosition
				}, 0uL);
			}
			string text = Regex.Replace(Text, "<[^>]+?\\/?>", (Match m) => (m.Value != "<focus>") ? "" : m.Value);
			int num = text.IndexOf("<focus>");
			((TMP_Text)Output).text = Text.Replace("<focus>", "");
			if (num > -1)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)ScrollRect).GetComponent<RectTransform>());
				if (((TMP_Text)Output).textInfo.characterInfo.Length > num)
				{
					float num2 = (float)((TMP_Text)Output).textInfo.characterInfo[num].lineNumber * (((TMP_Text)Output).fontSize + ((TMP_Text)Output).lineSpacing);
					float num3 = (((TMP_Text)Output).fontSize + ((TMP_Text)Output).lineSpacing) * 4f;
					Rect rect = ScrollRect.viewport.rect;
					float height = ((Rect)(ref rect)).height;
					rect = ScrollRect.content.rect;
					float height2 = ((Rect)(ref rect)).height;
					float num4 = height2 - ScrollRect.verticalNormalizedPosition * (height2 - height);
					float num5 = num4 - height;
					if (num2 - num3 < num5)
					{
						ScrollRect.verticalNormalizedPosition = 0f - (0f - height2 + (num2 - num3) + height) / (height2 - height);
					}
					else if (num2 + num3 > num4)
					{
						ScrollRect.verticalNormalizedPosition = (height2 - (num2 + num3)) / (height2 - height);
					}
				}
			}
			if (AddedLines)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)ScrollRect).GetComponent<RectTransform>());
				ScrollRect.verticalNormalizedPosition = 0f;
				AddedLines = false;
			}
			if (ScrollToTop)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(((Component)ScrollRect).GetComponent<RectTransform>());
				ScrollRect.verticalNormalizedPosition = 1f;
				ScrollToTop = false;
			}
		}

		public void SetText(string text, bool scrollToTop = true)
		{
			Text = text;
			if (scrollToTop)
			{
				ScrollToTop = scrollToTop;
			}
		}

		public void Clear()
		{
			Text = "";
		}

		public void WriteLine(string text)
		{
			Text = Text + text + "\r\n";
			AddedLines = true;
		}

		public void Exit()
		{
			if (RunningApplication != null)
			{
				RunningApplication.Exit();
				RunningApplication = null;
				if (!InputActivated)
				{
					ActivateInput();
				}
			}
		}

		public void DeactivateInput()
		{
			InputActivated = false;
			InputContainer.SetActive(false);
			((MonoBehaviour)Player.Controller).StartCoroutine(SelectInput());
		}

		public void ActivateInput()
		{
			InputActivated = true;
			InputContainer.SetActive(true);
			((MonoBehaviour)Player.Controller).StartCoroutine(SelectInput());
		}

		public void Start(IApplication application, string[] args = null)
		{
			if (application != null)
			{
				if (args == null)
				{
					args = new string[0];
				}
				SkipUpdate = true;
				RunningApplication = application;
				RunningApplication.Main(this, args);
			}
		}

		public void ScrollToText(int pos)
		{
			ScrollTo = pos;
		}
	}
	internal class Perk
	{
		public enum Type
		{
			PLAYER,
			SHIP
		}

		public string ID;

		public Type PerkType;

		public string Name;

		public string Description;

		public LobbyConfiguration.PerkConfiguration Configuration;

		private Func<float, float, int, float> Multiplier;

		private static Dictionary<string, Perk> AllPerks = new Dictionary<string, Perk>();

		private static Dictionary<Type, List<Perk>> ByType = new Dictionary<Type, List<Perk>>();

		public bool IsActive => Configuration.Active;

		public int[] Prices => Configuration.Prices;

		public float BaseValue => Configuration.Base;

		public float Change => Configuration.Change;

		public int Levels => Prices.Length;

		public string DisplayDescription => Description.Replace("[change]", (System.Math.Round(Change * 1000f) / 10.0).ToString(CultureInfo.InvariantCulture) ?? "");

		public static IReadOnlyDictionary<string, Perk> Perks => AllPerks;

		public static IReadOnlyCollection<Perk> PerksByType(Type type)
		{
			if (ByType.ContainsKey(type))
			{
				return ByType[type];
			}
			return new List<Perk>();
		}

		public Perk(Type type, string id, string name, string description, LobbyConfiguration.PerkConfiguration configuration, Func<float, float, int, float> multiplier)
		{
			if (AllPerks.ContainsKey(id))
			{
				throw new ArgumentException("Perk with ID '" + id + "' already exists!");
			}
			ID = id;
			PerkType = type;
			Name = name;
			Description = description;
			Configuration = configuration;
			Multiplier = multiplier;
			AllPerks.Add(id, this);
			if (!ByType.ContainsKey(type))
			{
				ByType.Add(type, new List<Perk>());
			}
			ByType[type].Add(this);
		}

		public float GetMultiplier(IUpgradeable upgradeable)
		{
			return Multiplier(BaseValue, Change, GetLevel(upgradeable));
		}

		public int GetTotalPrice(int level)
		{
			int num = 0;
			for (int i = 0; i < level && i < Levels; i++)
			{
				num += Price(i);
			}
			return num;
		}

		public int Price(int level)
		{
			if (level < Prices.Length)
			{
				return Prices[level];
			}
			return 0;
		}

		public int GetNextPrice(IUpgradeable upgradeable)
		{
			int level = GetLevel(upgradeable);
			if (level < Levels)
			{
				return Price(level);
			}
			return 0;
		}

		public int GetLevel(IUpgradeable upgradeable)
		{
			if ((upgradeable is Ship && PerkType != Type.SHIP) || (upgradeable is Player && PerkType != 0))
			{
				return 0;
			}
			int level = upgradeable.GetLevel(this);
			int num = level;
			if (num > Levels)
			{
				num = Levels;
			}
			return num;
		}

		public void IncreaseLevel(IUpgradeable upgradeable)
		{
			int num = GetLevel(upgradeable) + 1;
			if (num <= Levels)
			{
				upgradeable.SetLevel(this, upgradeable.GetLevel(this) + 1);
			}
		}
	}
	[LoadAssets]
	[HarmonyPatch]
	[Bootable]
	internal class Player : BaseUpgradeable
	{
		public enum SpeedType
		{
			Normal,
			SprintCrouching,
			Crouching,
			Falling
		}

		[Flags]
		public enum BodyLayers
		{
			NONE = 0,
			HIDE_FEET = 1
		}

		public enum Bone
		{
			METARIG,
			L_THIGH,
			L_SHIN,
			L_FOOT,
			L_HEEL,
			L_TOE,
			R_THIGH,
			R_SHIN,
			R_FOOT,
			R_HEEL,
			R_TOE,
			ROOT,
			SPINE_0,
			SPINE_1,
			SPINE_2,
			SPINE_3,
			L_SHOULDER,
			L_UPPER_ARM,
			L_LOWER_ARM,
			L_HAND,
			L_FINGER1,
			L_FINGER1_END,
			L_FINGER2,
			L_FINGER2_END,
			L_FINGER3,
			L_FINGER3_END,
			L_FINGER4,
			L_FINGER4_END,
			L_FINGER5,
			L_FINGER5_END,
			R_SHOULDER,
			R_UPPER_ARM,
			R_LOWER_ARM,
			R_HAND,
			R_FINGER1,
			R_FINGER1_END,
			R_FINGER2,
			R_FINGER2_END,
			R_FINGER3,
			R_FINGER3_END,
			R_FINGER4,
			R_FINGER4_END,
			R_FINGER5,
			R_FINGER5_END
		}

		public enum EgoBone
		{
			L_SHOULDER,
			L_UPPER_ARM,
			L_LOWER_ARM,
			L_HAND,
			L_FINGER1,
			L_FINGER1_END,
			L_FINGER2,
			L_FINGER2_END,
			L_FINGER3,
			L_FINGER3_END,
			L_FINGER4,
			L_FINGER4_END,
			L_FINGER5,
			L_FINGER5_END,
			R_SHOULDER,
			R_UPPER_ARM,
			R_LOWER_ARM,
			R_HAND,
			R_FINGER1,
			R_FINGER1_END,
			R_FINGER2,
			R_FINGER2_END,
			R_FINGER3,
			R_FINGER3_END,
			R_FINGER4,
			R_FINGER4_END,
			R_FINGER5,
			R_FINGER5_END
		}

		internal MobileTerminal MobileTerminal;

		private static Dictionary<int, Player> Players = new Dictionary<int, Player>();

		private static Mesh LOD1Mesh;

		private static Mesh LOD2Mesh;

		private static Mesh LOD3Mesh;

		private static Mesh WithoutFeetLOD1Mesh;

		private static Mesh WithoutFeetLOD2Mesh;

		private static Mesh WithoutFeetLOD3Mesh;

		private static GameObject HeadMountPrefab;

		internal List<GameObject> EquipmentItems;

		internal GameObject[] EquipmentItemsHead = (GameObject[])(object)new GameObject[0];

		internal GameObject[] EquipmentItemsBody = (GameObject[])(object)new GameObject[0];

		internal GameObject[] EquipmentItemsFeet = (GameObject[])(object)new GameObject[0];

		private SkinnedMeshRenderer LOD1;

		private SkinnedMeshRenderer LOD2;

		private SkinnedMeshRenderer LOD3;

		public GameObject HeadMount;

		public TransformAndName RadarTarget;

		public ulong SteamID;

		public PlayerControllerB Controller;

		public bool JoinedLate;

		private ulong _ClientID;

		private int _PlayerNum;

		private string _Username = "";

		public bool Initialized = false;

		public IHelmet Helmet;

		public Body Body;

		public Boots Boots;

		public bool LockInventory;

		private Dictionary<EgoBone, Transform> EgoBones = new Dictionary<EgoBone, Transform>();

		internal static Dictionary<string, EgoBone> EgoBoneNames = new Dictionary<string, EgoBone>
		{
			{
				"shoulder.L",
				EgoBone.L_SHOULDER
			},
			{
				"arm.L_upper",
				EgoBone.L_UPPER_ARM
			},
			{
				"arm.L_lower",
				EgoBone.L_LOWER_ARM
			},
			{
				"hand.L",
				EgoBone.L_HAND
			},
			{
				"finger1.L",
				EgoBone.L_FINGER1
			},
			{
				"finger1.L.001",
				EgoBone.L_FINGER1_END
			},
			{
				"finger2.L",
				EgoBone.L_FINGER2
			},
			{
				"finger2.L.001",
				EgoBone.L_FINGER2_END
			},
			{
				"finger3.L",
				EgoBone.L_FINGER3
			},
			{
				"finger3.L.001",
				EgoBone.L_FINGER3_END
			},
			{
				"finger4.L",
				EgoBone.L_FINGER4
			},
			{
				"finger4.L.001",
				EgoBone.L_FINGER4_END
			},
			{
				"finger5.L",
				EgoBone.L_FINGER5
			},
			{
				"finger5.L.001",
				EgoBone.L_FINGER5_END
			},
			{
				"shoulder.R",
				EgoBone.R_SHOULDER
			},
			{
				"arm.R_upper",
				EgoBone.R_UPPER_ARM
			},
			{
				"arm.R_lower",
				EgoBone.R_LOWER_ARM
			},
			{
				"hand.R",
				EgoBone.R_HAND
			},
			{
				"finger1.R",
				EgoBone.R_FINGER1
			},
			{
				"finger1.R.001",
				EgoBone.R_FINGER1_END
			},
			{
				"finger2.R",
				EgoBone.R_FINGER2
			},
			{
				"finger2.R.001",
				EgoBone.R_FINGER2_END
			},
			{
				"finger3.R",
				EgoBone.R_FINGER3
			},
			{
				"finger3.R.001",
				EgoBone.R_FINGER3_END
			},
			{
				"finger4.R",
				EgoBone.R_FINGER4
			},
			{
				"finger4.R.001",
				EgoBone.R_FINGER4_END
			},
			{
				"finger5.R",
				EgoBone.R_FINGER5
			},
			{
				"finger5.R.001",
				EgoBone.R_FINGER5_END
			}
		};

		private Dictionary<Bone, Transform> Bones = new Dictionary<Bone, Transform>();

		internal static Dictionary<string, Bone> BoneNames = new Dictionary<string, Bone>
		{
			{
				"metarig",
				Bone.METARIG
			},
			{
				"spine",
				Bone.ROOT
			},
			{
				"spine.001",
				Bone.SPINE_0
			},
			{
				"spine.002",
				Bone.SPINE_1
			},
			{
				"spine.003",
				Bone.SPINE_2
			},
			{
				"spine.004",
				Bone.SPINE_3
			},
			{
				"shoulder.L",
				Bone.L_SHOULDER
			},
			{
				"arm.L_upper",
				Bone.L_UPPER_ARM
			},
			{
				"arm.L_lower",
				Bone.L_LOWER_ARM
			},
			{
				"hand.L",
				Bone.L_HAND
			},
			{
				"finger1.L",
				Bone.L_FINGER1
			},
			{
				"finger1.L.001",
				Bone.L_FINGER1_END
			},
			{
				"finger2.L",
				Bone.L_FINGER2
			},
			{
				"finger2.L.001",
				Bone.L_FINGER2_END
			},
			{
				"finger3.L",
				Bone.L_FINGER3
			},
			{
				"finger3.L.001",
				Bone.L_FINGER3_END
			},
			{
				"finger4.L",
				Bone.L_FINGER4
			},
			{
				"finger4.L.001",
				Bone.L_FINGER4_END
			},
			{
				"finger5.L",
				Bone.L_FINGER5
			},
			{
				"finger5.L.001",
				Bone.L_FINGER5_END
			},
			{
				"shoulder.R",
				Bone.R_SHOULDER
			},
			{
				"arm.R_upper",
				Bone.R_UPPER_ARM
			},
			{
				"arm.R_lower",
				Bone.R_LOWER_ARM
			},
			{
				"hand.R",
				Bone.R_HAND
			},
			{
				"finger1.R",
				Bone.R_FINGER1
			},
			{
				"finger1.R.001",
				Bone.R_FINGER1_END
			},
			{
				"finger2.R",
				Bone.R_FINGER2
			},
			{
				"finger2.R.001",
				Bone.R_FINGER2_END
			},
			{
				"finger3.R",
				Bone.R_FINGER3
			},
			{
				"finger3.R.001",
				Bone.R_FINGER3_END
			},
			{
				"finger4.R",
				Bone.R_FINGER4
			},
			{
				"finger4.R.001",
				Bone.R_FINGER4_END
			},
			{
				"finger5.R",
				Bone.R_FINGER5
			},
			{
				"finger5.R.001",
				Bone.R_FINGER5_END
			},
			{
				"thigh.L",
				Bone.L_THIGH
			},
			{
				"shin.L",
				Bone.L_SHIN
			},
			{
				"foot.L",
				Bone.L_FOOT
			},
			{
				"heel.02.L",
				Bone.L_HEEL
			},
			{
				"toe.L",
				Bone.L_TOE
			},
			{
				"thigh.R",
				Bone.R_THIGH
			},
			{
				"shin.R",
				Bone.R_SHIN
			},
			{
				"foot.R",
				Bone.R_FOOT
			},
			{
				"heel.02.R",
				Bone.R_HEEL
			},
			{
				"toe.R",
				Bone.R_TOE
			}
		};

		internal List<Light> CosmeticLights = new List<Light>();

		internal Dictionary<string, float> MultiplierOverrides = new Dictionary<string, float>();

		private bool CosmeticsHidden = false;

		public string[] Cosmetics;

		public Dictionary<string, GameObject> AppliedCosmetics = new Dictionary<string, GameObject>();

		internal Dictionary<string, AnimationClip> OriginalClips = new Dictionary<string, AnimationClip>();

		public ulong ClientID
		{
			get
			{
				return _ClientID;
			}
			set
			{
				_ClientID = value;
			}
		}

		public int PlayerNum
		{
			get
			{
				return _PlayerNum;
			}
			set
			{
				_PlayerNum = value;
			}
		}

		public string Username
		{
			get
			{
				return _Username;
			}
			set
			{
				_Username = value;
			}
		}

		public bool IsLocal => (Object)(object)Controller != (Object)null && (Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)Controller == (Object)(object)GameNetworkManager.Instance.localPlayerController;

		public bool IsJumping
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isJumping;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isJumping = value;
				}
			}
		}

		public bool IsPlayerSliding
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isPlayerSliding;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isPlayerSliding = value;
				}
			}
		}

		public bool IsOwner
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return ((NetworkBehaviour)Controller).IsOwner;
			}
		}

		public Coroutine JumpCoroutine
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return null;
				}
				return Controller.jumpCoroutine;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.jumpCoroutine = value;
				}
			}
		}

		public float PlayerSlidingTimer
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0f;
				}
				return Controller.playerSlidingTimer;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.playerSlidingTimer = value;
				}
			}
		}

		public bool IsPlayerControlled
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isPlayerControlled;
			}
		}

		public bool IsServer
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return ((NetworkBehaviour)Controller).IsServer;
			}
		}

		public bool IsHostPlayerObject
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isHostPlayerObject;
			}
		}

		public bool IsTestingPlayer
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isTestingPlayer;
			}
		}

		public bool IsFallingFromJump
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isFallingFromJump;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isFallingFromJump = value;
				}
			}
		}

		public bool IsFallingNoJump
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isFallingNoJump;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isFallingNoJump = value;
				}
			}
		}

		public bool MovingForward
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.movingForward;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.movingForward = value;
				}
			}
		}

		public bool IsWalking
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isWalking;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isWalking = value;
				}
			}
		}

		public float SprintMultiplier
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0f;
				}
				return Controller.sprintMultiplier;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.sprintMultiplier = value;
				}
			}
		}

		public Vector3 WalkForce
		{
			get
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Controller == (Object)null)
				{
					return Vector3.zero;
				}
				return Controller.walkForce;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.walkForce = value;
				}
			}
		}

		public QuickMenuManager QuickMenuManager
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return null;
				}
				return Controller.quickMenuManager;
			}
		}

		public bool InSpecialInteractAnimation
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.inSpecialInteractAnimation;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.inSpecialInteractAnimation = value;
				}
			}
		}

		public bool IsTypingChat
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isTypingChat;
			}
		}

		public bool IsUnderwater
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isUnderwater;
			}
		}

		public int IsMovementHindered
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0;
				}
				return Controller.isMovementHindered;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.isMovementHindered = value;
				}
			}
		}

		public int MovementHinderedPrev
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0;
				}
				return Controller.movementHinderedPrev;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.movementHinderedPrev = value;
				}
			}
		}

		public bool IsCrouching
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.isCrouching;
			}
		}

		public bool IsGrounded
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return false;
				}
				return Controller.thisController.isGrounded;
			}
		}

		public float FallValue
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0f;
				}
				return Controller.fallValue;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.fallValue = value;
				}
			}
		}

		public float FallValueUncapped
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0f;
				}
				return Controller.fallValueUncapped;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.fallValueUncapped = value;
				}
			}
		}

		public float JumpForce
		{
			get
			{
				if ((Object)(object)Controller == (Object)null)
				{
					return 0f;
				}
				return Controller.jumpForce;
			}
			set
			{
				if ((Object)(object)Controller != (Object)null)
				{
					Controller.jumpForce = value;
				}
			}
		}

		public static void Reset()
		{
			Players = new Dictionary<int, Player>();
		}

		public IEnumerator PlayerJump()
		{
			if ((Object)(object)Controller == (Object)null)
			{
				return null;
			}
			return Controller.PlayerJump();
		}

		public static void Boot()
		{
			RenderPipelineManager.beginCameraRendering += RenderPipelineManager_beginCameraRendering;
			RenderPipelineManager.endCameraRendering += RenderPipelineManager_endCameraRendering;
			AdvancedCompany.Network.Manager.AddListener(delegate(CosmeticsSync msg)
			{
				if ((int)GameNetworkManager.Instance.localPlayerController.playerClientId != msg.PlayerNum)
				{
					GetPlayer(msg.PlayerNum)?.SetCosmetics(msg.Cosmetics, sendMessage: false);
				}
			});
			AdvancedCompany.Network.Manager.AddListener(delegate(SyncAnimationOverride msg)
			{
				if ((int)GameNetworkManager.Instance.localPlayerController.playerClientId != msg.PlayerNum)
				{
					GetPlayer(msg.PlayerNum)?.NetworkOverride(msg.OriginalName, msg.ReplacementName);
				}
			});
		}

		private static void RenderPipelineManager_endCameraRendering(ScriptableRenderContext arg1, Camera arg2)
		{
		}

		private static void RenderPipelineManager_beginCameraRendering(ScriptableRenderContext arg1, Camera arg2)
		{
			if ((Object)(object)StartOfRound.Instance != (Object)null && (Object)(object)StartOfRound.Instance.localPlayerController != (Object)null)
			{
				Player player = GetPlayer(StartOfRound.Instance.localPlayerController);
				player.ShowCosmeticLights();
				if ((Object)(object)player.Controller != (Object)null && (Object)(object)arg2 == (Object)(object)player.Controller.gameplayCamera)
				{
					player.HideCosmeticLights();
				}
			}
		}

		internal void ShowCosmeticLights()
		{
			foreach (Light cosmeticLight in CosmeticLights)
			{
				((Behaviour)cosmeticLight).enabled = true;
			}
		}

		internal void HideCosmeticLights()
		{
			foreach (Light cosmeticLight in CosmeticLights)
			{
				((Behaviour)cosmeticLight).enabled = false;
			}
		}

		public Transform GetBone(Bone bone)
		{
			if (Bones.ContainsKey(bone))
			{
				return Bones[bone];
			}
			return null;
		}

		public Transform GetBone(EgoBone bone)
		{
			if (EgoBones.ContainsKey(bone))
			{
				return EgoBones[bone];
			}
			return null;
		}

		public void BindSkinnedMeshRenderer(SkinnedMeshRenderer skinnedMeshRenderer, Bone root, Bone[] bones)
		{
			skinnedMeshRenderer.rootBone = GetBone(root);
			Transform[] array = (Transform[])(object)new Transform[bones.Length];
			for (int i = 0; i < bones.Length; i++)
			{
				array[i] = GetBone(bones[i]);
			}
			skinnedMeshRenderer.bones = array;
			((Renderer)skinnedMeshRenderer).ResetBounds();
		}

		public static void LoadAssets(AssetBundle assets)
		{
			WithoutFeetLOD1Mesh = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/WFLOD1.prefab").GetComponent<SkinnedMeshRenderer>().sharedMesh;
			WithoutFeetLOD2Mesh = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/WFLOD2.prefab").GetComponent<SkinnedMeshRenderer>().sharedMesh;
			WithoutFeetLOD3Mesh = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/WFLOD3.prefab").GetComponent<SkinnedMeshRenderer>().sharedMesh;
			HeadMountPrefab = assets.LoadAsset<GameObject>("Assets/Prefabs/Skins/HeadMount.prefab");
		}

		public static Player GetPlayer(int playerNum)
		{
			if (Players.TryGetValue(playerNum, out var value))
			{
				return value;
			}
			Players.Add(playerNum, new Player(playerNum));
			return Players[playerNum];
		}

		public static Player GetPlayer(PlayerControllerB controller)
		{
			int key = (int)controller.playerClientId;
			if (!Players.ContainsKey(key))
			{
				Players.Add(key, new Player(controller));
			}
			if ((Object)(object)Players[key].Controller == (Object)null)
			{
				Players[key].SetController(controller);
			}
			return Players[key];
		}

		internal Player()
		{
		}

		protected Player(int clientID)
		{
			PlayerNum = clientID;
		}

		protected Player(PlayerControllerB controller)
		{
			SetController(controller);
		}

		protected void SetController(PlayerControllerB controller)
		{
			if ((Object)(object)controller == (Object)null)
			{
				return;
			}
			PlayerNum = (int)controller.playerClientId;
			Controller = controller;
			Transform val = ((Component)Controller).transform.Find("ScavengerModel");
			if (!((Object)(object)val == (Object)null))
			{
				LOD1 = ((Component)val.Find("LOD1")).GetComponent<SkinnedMeshRenderer>();
				LOD2 = ((Component)val.Find("LOD2")).GetComponent<SkinnedMeshRenderer>();
				LOD3 = ((Component)val.Find("LOD3")).GetComponent<SkinnedMeshRenderer>();
				if ((Object)(object)LOD1Mesh == (Object)null)
				{
					LOD1Mesh = LOD1.sharedMesh;
				}
				if ((Object)(object)LOD2Mesh == (Object)null)
				{
					LOD2Mesh = LOD2.sharedMesh;
				}
				if ((Object)(object)LOD3Mesh == (Object)null)
				{
					LOD3Mesh = LOD3.sharedMesh;
				}
				Transform val2 = val.Find("metarig");
				Bones.Add(Bone.METARIG, val2);
				FindBones(val2);
				Transform transform = val2.Find("ScavengerModelArmsOnly");
				FindEgoBones(transform);
				SetCosmetics(Cosmetics, sendMessage: false);
				if (MobileTerminal == null)
				{
					MobileTerminal = new MobileTerminal(this);
				}
			}
		}

		protected void FindBones(Transform transform)
		{
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (!(((Object)child).name == "ScavengerModelArmsOnly"))
				{
					if (BoneNames.ContainsKey(((Object)child).name))
					{
						Bones.Add(BoneNames[((Object)child).name], child);
					}
					FindBones(child);
				}
			}
		}

		protected void FindEgoBones(Transform transform)
		{
			for (int i = 0; i < transform.childCount; i++)
			{
				Transform child = transform.GetChild(i);
				if (EgoBoneNames.ContainsKey(((Object)child).name))
				{
					EgoBones.Add(EgoBoneNames[((Object)child).name], child);
				}
				FindEgoBones(child);
			}
		}

		public static void Update()
		{
			foreach (KeyValuePair<int, Player> player in Players)
			{
				player.Value.UpdateInstance();
			}
		}

		public void UnequipAll()
		{
			if ((Object)(object)Controller == (Object)null)
			{
				return;
			}
			if (EquipmentItemsBody != null)
			{
				for (int i = 0; i < EquipmentItemsBody.Length; i++)
				{
					Object.Destroy((Object)(object)EquipmentItemsBody[i]);
				}
			}
			if (EquipmentItemsFeet != null)
			{
				for (int j = 0; j < EquipmentItemsFeet.Length; j++)
				{
					Object.Destroy((Object)(object)EquipmentItemsFeet[j]);
				}
			}
			if (EquipmentItemsHead != null)
			{
				for (int k = 0; k < EquipmentItemsHead.Length; k++)
				{
					Object.Destroy((Object)(object)EquipmentItemsHead[k]);
				}
			}
			if (Helmet != null)
			{
				Helmet.Unequipped(this);
			}
			if ((Object)(object)Body != (Object)null)
			{
				Body.Unequipped(this);
			}
			if ((Object)(object)Boots != (Object)null)
			{
				Boots.Unequipped(this);
			}
			Helmet = null;
			Body = null;
			Boots = null;
			EquipmentItemsBody = (GameObject[])(object)new GameObject[0];
			EquipmentItemsFeet = (GameObject[])(object)new GameObject[0];
			EquipmentItemsHead = (GameObject[])(object)new GameObject[0];
			LOD1.sharedMesh = LOD1Mesh;
			LOD2.sharedMesh = LOD2Mesh;
			LOD3.sharedMesh = LOD3Mesh;
		}

		public void Reequip(bool head = true, bool body = true, bool feet = true)
		{
			if (!((Object)(object)Controller == (Object)null))
			{
				BodyLayers bodyLayers = BodyLayers.NONE;
				if (Helmet != null)
				{
					bodyLayers |= Helmet.GetLayers();
				}
				if ((Object)(object)Body != (Object)null)
				{
					bodyLayers |= Body.GetLayers();
				}
				if ((Object)(object)Boots != (Object)null)
				{
					bodyLayers |= Boots.GetLayers();
				}
				if (head)
				{
					ReequipHead();
				}
				if (body)
				{
					ReequipBody();
				}
				if (feet)
				{
					ReequipFeet();
				}
				if ((bodyLayers & BodyLayers.HIDE_FEET) == BodyLayers.HIDE_FEET)
				{
					LOD1.sharedMesh = WithoutFeetLOD1Mesh;
					LOD2.sharedMesh = WithoutFeetLOD2Mesh;
					LOD3.sharedMesh = WithoutFeetLOD3Mesh;
				}
				else
				{
					LOD1.sharedMesh = LOD1Mesh;
					LOD2.sharedMesh = LOD2Mesh;
					LOD3.sharedMesh = LOD3Mesh;
				}
			}
		}

		public void ReequipFeet()
		{
			if ((Object)(object)Controller == (Object)null)
			{
				return;
			}
			if (EquipmentItemsFeet != null)
			{
				for (int i = 0; i < EquipmentItemsFeet.Length; i++)
				{
					Object.Destroy((Object)(object)EquipmentItemsFeet[i]);
				}
			}
			List<GameObject> list = new List<GameObject>();
			if ((Object)(object)Boots != (Object)null)
			{
				GameObject[] array = Boots.CreateWearable(this);
				list.AddRange(array);
				if (ClientConfiguration.Instance.Compability.HideEquipment)
				{
					HideRenderers(array);
				}
			}
			EquipmentItemsFeet = list.ToArray();
			Equipment.NewFeet(Controller, EquipmentItemsFeet);
		}

		private void HideRenderers(GameObject[] objs)
		{
			foreach (GameObject val in objs)
			{
				MeshRenderer component = val.GetComponent<MeshRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					((Renderer)component).enabled = false;
				}
				SkinnedMeshRenderer component2 = val.GetComponent<SkinnedMeshRenderer>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Renderer)component2).enabled = false;
				}
				MeshRenderer[] componentsInChildren = val.GetComponentsInChildren<MeshRenderer>();
				SkinnedMeshRenderer[] componentsInChildren2 = val.GetComponentsInChildren<SkinnedMeshRenderer>();
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val2 in array)
				{
					((Renderer)val2).enabled = false;
				}
				SkinnedMeshRenderer[] array2 = componentsInChildren2;
				foreach (SkinnedMeshRenderer val3 in array2)
				{
					((Renderer)val3).enabled = false;
				}
			}
		}

		public void ReequipBody()
		{
			if ((Object)(object)Controller == (Object)null)
			{
				return;
			}
			if (EquipmentItemsBody != null)
			{
				for (int i = 0; i < EquipmentItemsBody.Length; i++)
				{
					Object.Destroy((Object)(object)EquipmentItemsBody[i]);
				}
			}
			List<GameObject> list = new List<GameObject>();
			if ((Object)(object)Body != (Object)null)
			{
				GameObject[] array = Body.CreateWearable(this);
				list.AddRange(array);
				if (ClientConfiguration.Instance.Compability.HideEquipment)
				{
					HideRenderers(array);
				}
			}
			EquipmentItemsBody = list.ToArray();
			Equipment.NewBody(Controller, EquipmentItemsBody);
		}

		public void ReequipHead()
		{
			if ((Object)(object)Controller == (Object)null)
			{
				return;
			}
			if (EquipmentItemsHead != null)
			{
				for (int i = 0; i < EquipmentItemsHead.Length; i++)
				{
					Object.Destroy((Object)(object)EquipmentItemsHead[i]);
				}
			}
			List<GameObject> list = new List<GameObject>();
			if (Helmet != null)
			{
				GameObject[] array = Helmet.CreateWearable(this);
				list.AddRange(array);
				if (ClientConfiguration.Instance.Compability.HideEquipment)
				{
					HideRenderers(array);
				}
			}
			EquipmentItemsHead = list.ToArray();
			Equipment.NewHead(Controller, EquipmentItemsHead);
		}

		public void UpdateInstance()
		{
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Controller == (Object)null && (Object)(object)StartOfRound.Instance != (Object)null)
			{
				for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
				{
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
					if ((int)val.playerClientId == PlayerNum)
					{
						if (i != PlayerNum)
						{
							Plugin.Log.LogWarning((object)("Wrong player script " + i + " had playerClientId " + PlayerNum + ". This might result in desyncs. Some other mod might have caused this."));
						}
						SetController(val);
					}
				}
			}
			if (!((Object)(object)Controller != (Object)null))
			{
				return;
			}
			if (Controller.playerUsername != Username)
			{
				if (SteamID != 0)
				{
					QuickMenuManager.playerListSlots[Controller.playerClientId].playerSteamId = SteamID;
				}
				((TMP_Text)QuickMenuManager.playerListSlots[Controller.playerClientId].usernameHeader).text = Username;
				Controller.playerUsername = Username;
				((TMP_Text)Controller.usernameBillboardText).text = Username;
				RadarTarget.name = Username ?? "";
			}
			if ((!Controller.isPlayerControlled && !Controller.isPlayerDead) || !((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null))
			{
				return;
			}
			if (!ServerConfiguration.Instance.General.DeactivateHotbar)
			{
				if ((Object)(object)HeadMount == (Object)null)
				{
					HeadMount = Object.Instantiate<GameObject>(HeadMountPrefab, GetBone(Bone.SPINE_3));
					HeadMount.transform.localRotation = Quaternion.Euler(new Vector3(88.47f, 0f, 0f));
					HeadMount.transform.localPosition = new Vector3(0f, 0.3336f, 0.1184f);
					HeadMount.transform.localScale = new Vector3(0.8915f, 0.8915f, 0.8915f);
					if ((Object)(object)Controller == (Object)(object)GameNetworkManager.Instance.localPlayerController)
					{
						Renderer component = HeadMount.GetComponent<Renderer>();
						((Component)component).gameObject.layer = 23;
					}
					if (ClientConfiguration.Instance.Compability.HideEquipment)
					{
						((Renderer)HeadMount.GetComponent<MeshRenderer>()).enabled = false;
					}
				}
				if ((Object)(object)HeadMount != (Object)null && InventoryPatches.HeadSlotAvailable != HeadMount.activeSelf)
				{
					HeadMount.SetActive(InventoryPatches.HeadSlotAvailable);
				}
				GrabbableObject val2 = Controller.ItemSlots[10];
				GrabbableObject val3 = Controller.ItemSlots[11];
				GrabbableObject val4 = Controller.ItemSlots[12];
				bool flag = false;
				bool flag2 = false;
				bool flag3 = false;
				if ((Object)(object)val2 == (Object)null && Helmet != null)
				{
					Helmet.Unequipped(this);
					Helmet = null;
					flag = true;
				}
				else if ((Object)(object)val2 != (Object)null && val2 is IHelmet helmet && Helmet != helmet)
				{
					if (Helmet != null)
					{
						Helmet.Unequipped(this);
					}
					Helmet = helmet;
					flag = true;
					Helmet.Equipped(this);
				}
				if ((Object)(object)val3 == (Object)null && (Object)(object)Body != (Object)null)
				{
					Body.Unequipped(this);
					Body = null;
					flag2 = true;
				}
				else if ((Object)(object)val3 != (Object)null && val3 is Body body && (Object)(object)Body != (Object)(object)body)
				{
					if ((Object)(object)Body != (Object)null)
					{
						Body.Unequipped(this);
					}
					Body = body;
					flag2 = true;
					Body.Equipped(this);
				}
				if ((Object)(object)val4 == (Object)null && (Object)(object)Boots != (Object)null)
				{
					Boots.Unequipped(this);
					Boots = null;
					flag3 = true;
				}
				else if ((Object)(object)val4 != (Object)null && val4 is Boots boots && (Object)(object)Boots != (Object)(object)boots)
				{
					if ((Object)(object)Boots != (Object)null)
					{
						Boots.Unequipped(this);
					}
					Boots = boots;
					flag3 = true;
					Boots.Equipped(this);
				}
				if (flag || flag2 || flag3)
				{
					Reequip(flag, flag2, flag3);
				}
			}
			if (IsLocal)
			{
				MultiplierOverrides.Clear();
				if (Boots is ICursed cursed)
				{
					cursed.UpdateEffects(this);
				}
				if (Helmet is ICursed cursed2)
				{
					cursed2.UpdateEffects(this);
				}
				if (Body is ICursed cursed3)
				{
					cursed3.UpdateEffects(this);
				}
				if (Controller.currentlyHeldObjectServer is ICursed cursed4)
				{
					cursed4.UpdateEffects(this);
				}
				bool flag4 = false;
				if (Helmet is IEquipmentCommunication)
				{
					flag4 = true;
				}
				if (Boots is IEquipmentCommunication)
				{
					flag4 = true;
				}
				if (Body is IEquipmentCommunication)
				{
					flag4 = true;
				}
				if (flag4)
				{
					Controller.holdingWalkieTalkie = true;
				}
			}
		}

		public void SetMultiplierOverride(string perk, float val)
		{
			MultiplierOverrides[perk] = val;
		}

		protected void InstancePerformJump()
		{
			if (Boots is IPerformJump performJump)
			{
				performJump.PerformJump(this);
			}
			if (Helmet is IPerformJump performJump2)
			{
				performJump2.PerformJump(this);
			}
			if (Body is IPerformJump performJump3)
			{
				performJump3.PerformJump(this);
			}
			if (Controller.currentlyHeldObjectServer is IPerformJump performJump4)
			{
				performJump4.PerformJump(this);
			}
		}

		protected void InstanceOnUpdate()
		{
			if (Boots is IOnUpdate onUpdate)
			{
				onUpdate.OnUpdate(this);
			}
			if (Helmet is IOnUpdate onUpdate2)
			{
				onUpdate2.OnUpdate(this);
			}
			if (Body is IOnUpdate onUpdate3)
			{
				onUpdate3.OnUpdate(this);
			}
			if (Controller.currentlyHeldObjectServer is IOnUpdate onUpdate4)
			{
				onUpdate4.OnUpdate(this);
			}
		}

		protected bool InstanceMovement()
		{
			if (Boots is IMovement movement && movement.Movement(this))
			{
				return true;
			}
			if (Helmet is IMovement movement2 && movement2.Movement(this))
			{
				return true;
			}
			if (Body is IMovement movement3 && movement3.Movement(this))
			{
				return true;
			}
			if (Controller.currentlyHeldObjectServer is IMovement movement4 && movement4.Movement(this))
			{
				return true;
			}
			return false;
		}

		public static void PerformJump(PlayerControllerB player)
		{
			GetPlayer(player).InstancePerformJump();
		}

		public static void OnUpdate(PlayerControllerB player)
		{
			GetPlayer(player).InstanceOnUpdate();
		}

		public static bool Movement(PlayerControllerB player)
		{
			return GetPlayer(player).InstanceMovement();
		}

		public override void Reset(bool resetXP)
		{
			base.Reset(resetXP);
			if (resetXP)
			{
				XP = (ServerConfiguration.Instance.General.SaveProgress ? 500 : ServerConfiguration.Instance.General.StartingXP);
			}
		}

		public void CopyFrom(Player player)
		{
			XP = player.XP;
			Levels = player.Levels;
			_Username = player._Username;
			SteamID = player.SteamID;
			JoinedLate = player.JoinedLate;
			ClientID = player.ClientID;
			Cosmetics = player.Cosmetics?.ToArray() ?? new string[0];
		}

		public override void ReadData(FastBufferReader reader)
		{
			//IL_0002: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			base.ReadData(reader);
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref SteamID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref _ClientID, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref _PlayerNum, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref JoinedLate, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref _Username, false);
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			Cosmetics = new string[num];
			string text = default(string);
			for (int i = 0; i < num; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref text, true);
				Cosmetics[i] = text;
			}
		}

		public override void WriteData(FastBufferWriter writer)
		{
			//IL_0002: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			base.WriteData(writer);
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref SteamID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref _ClientID, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref _PlayerNum, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref JoinedLate, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(_Username, false);
			if (Cosmetics != null)
			{
				int num = Cosmetics.Length;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				for (int i = 0; i < Cosmetics.Length; i++)
				{
					((FastBufferWriter)(ref writer)).WriteValueSafe(Cosmetics[i], true);
				}
			}
			else
			{
				int num = 0;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref num, default(ForPrimitives));
			}
		}

		private string GetLocalSaveFile(bool backup = false)
		{
			if (ClientConfiguration.Instance.File.SaveInProfile)
			{
				string path = Path.Combine(Paths.ConfigPath, "../saves/advancedcompany");
				if (!Directory.Exists(path))
				{
					Directory.CreateDirectory(path);
				}
				return Path.Combine(Paths.ConfigPath, "../saves/advancedcompany/savefile" + (backup ? ".bkp" : ""));
			}
			return Path.Combine(Path.GetFullPath(Environment.ExpandEnvironmentVariables("%appdata%/../LocalLow/ZeekerssRBLX/Lethal Company")), "AdvancedCompany" + (backup ? ".bkp" : ""));
		}

		private string NoPunctuation(string input)
		{
			return new string(input.Where((char c) => char.IsLetter(c)).ToArray());
		}

		public void LoadLocal()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			string localSaveFile = GetLocalSaveFile();
			try
			{
				if (!GameNetworkManager.Instance.disableSteam)
				{
					SteamID = SteamClient.SteamId.Value;
					Friend val = new Friend(SteamId.op_Implicit(SteamID));
					string input = NoPunctuation(((Friend)(ref val)).Name);
					input = Regex.Replace(input, "[^\\w\\._]", "");
					Username = input;
					Plugin.Log.LogMessage((object)("Found steam ID: " + SteamID));
					Plugin.Log.LogMessage((object)("Found username: " + Username));
				}
				else
				{
					SteamID = 0uL;
					Username = "Player";
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)"Error while retrieving steam ID:");
				Plugin.Log.LogError((object)ex);
				SteamID = 0uL;
			}
			try
			{
				Cosmetics = ClientConfiguration.Instance.Cosmetics.ActivatedCosmetics.ToArray();
				if (File.Exists(localSaveFile))
				{
					JObject val2 = JObject.Parse(File.ReadAllText(localSaveFile));
					val2.TryGetInt("xp", out XP);
					if (val2.ContainsKey("perks"))
					{
						JToken obj = val2["perks"];
						JObject val3 = (JObject)(object)((obj is JObject) ? obj : null);
						if (val3 != null)
						{
							foreach (KeyValuePair<string, JToken> item in val3)
							{
								if (int.TryParse(((object)item.Value).ToString(), out var result))
								{
									Levels.Add(item.Key, result);
								}
							}
						}
					}
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)"Error while loading savegame:");
				Plugin.Log.LogWarning((object)ex2);
				Plugin.Log.LogMessage((object)"Trying to load backup...");
				localSaveFile = GetLocalSaveFile(backup: true);
				try
				{
					if (File.Exists(localSaveFile))
					{
						JObject val4 = JObject.Parse(File.ReadAllText(localSaveFile));
						val4.TryGetInt("xp", out XP);
						if (val4.ContainsKey("perks"))
						{
							JToken obj2 = val4["perks"];
							JObject val5 = (JObject)(object)((obj2 is JObject) ? obj2 : null);
							if (val5 != null)
							{
								foreach (KeyValuePair<string, JToken> item2 in val5)
								{
									if (int.TryParse(((object)item2.Value).ToString(), out var result2))
									{
										Levels.Add(item2.Key, result2);
									}
								}
							}
						}
					}
					Plugin.Log.LogMessage((object)"Rewrite savegame from backup...");
					SaveLocal(saveBackup: false);
				}
				catch (Exception ex3)
				{
					Plugin.Log.LogError((object)"Error while loading savegame backup:");
					Plugin.Log.LogError((object)ex3);
				}
			}
			if (XP < 500)
			{
				XP = 500;
			}
		}

		public void EquipConfigurationCosmetics()
		{
			SetCosmetics(ClientConfiguration.Instance.Cosmetics.ActivatedCosmetics.ToArray(), sendMessage: false);
		}

		public void ShowCosmetics()
		{
			CosmeticsHidden = false;
			foreach (KeyValuePair<string, GameObject> appliedCosmetic in AppliedCosmetics)
			{
				appliedCosmetic.Value.SetActive(true);
			}
		}

		public void HideCosmetics()
		{
			CosmeticsHidden = true;
			foreach (KeyValuePair<string, GameObject> appliedCosmetic in AppliedCosmetics)
			{
				appliedCosmetic.Value.SetActive(false);
			}
		}

		public void SetCosmetics(string[] cosmetics, bool sendMessage = true)
		{
			if (ServerConfiguration.Instance.General.EnableCosmetics)
			{
				if (cosmetics == null)
				{
					cosmetics = new string[0];
				}
				Cosmetics = cosmetics;
				if (!((Object)(object)Controller != (Object)null))
				{
					return;
				}
				if (Lobby.LocalPlayerNum == (int)Controller.playerClientId && sendMessage)
				{
					AdvancedCompany.Network.Manager.Send(new CosmeticsSync
					{
						PlayerNum = PlayerNum,
						Cosmetics = cosmetics
					}, 0uL);
				}
				if (ClientConfiguration.Instance.Compability.HideCosmetics)
				{
					return;
				}
				Plugin.Log.LogMessage((object)("Applying cosmetics for " + PlayerNum));
				Plugin.Log.LogMessage((object)string.Join(" ", Cosmetics));
				List<string> list = new List<string>();
				List<string> list2 = new List<string>();
				foreach (KeyValuePair<string, GameObject> appliedCosmetic in AppliedCosmetics)
				{
					if (!cosmetics.Contains(appliedCosmetic.Key))
					{
						list.Add(appliedCosmetic.Key);
					}
				}
				string[] cosmetics2 = Cosmetics;
				foreach (string text in cosmetics2)
				{
					if (!AppliedCosmetics.ContainsKey(text))
					{
						list2.Add(text);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					Object.Destroy((Object)(object)AppliedCosmetics[list[j]]);
					AppliedCosmetics.Remove(list[j]);
				}
				for (int k = 0; k < list2.Count; k++)
				{
					AddCosmetic(list2[k]);
				}
				CosmeticLights.Clear();
				{
					foreach (KeyValuePair<string, GameObject> appliedCosmetic2 in AppliedCosmetics)
					{
						Light[] componentsInChildren = appliedCosmetic2.Value.GetComponentsInChildren<Light>();
						CosmeticLights.AddRange(componentsInChildren);
					}
					return;
				}
			}
			Cosmetics = new string[0];
		}

		private void AddCosmetic(string id)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (CosmeticDatabase.AllCosmetics.ContainsKey(id))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)CosmeticDatabase.AllCosmetics[id]).gameObject);
				CosmeticInstance component = val.GetComponent<CosmeticInstance>();
				Transform val2 = null;
				switch (component.cosmeticType)
				{
				case CosmeticType.HAT:
					val2 = GetBone(Bone.SPINE_3);
					break;
				case CosmeticType.CHEST:
					val2 = GetBone(Bone.SPINE_2);
					break;
				case CosmeticType.HIP:
					val2 = GetBone(Bone.ROOT);
					break;
				case CosmeticType.R_LOWER_ARM:
					val2 = GetBone(Bone.R_LOWER_ARM);
					break;
				case CosmeticType.L_SHIN:
					val2 = GetBone(Bone.L_SHIN);
					break;
				case CosmeticType.R_SHIN:
					val2 = GetBone(Bone.R_SHIN);
					break;
				}
				val.transform.position = val2.position;
				val.transform.rotation = val2.rotation;
				Transform transform = val.transform;
				transform.localScale *= 0.38f;
				val.transform.parent = val2;
				if ((int)Controller.playerClientId == Lobby.LocalPlayerNum)
				{
					MeshRenderer component2 = val.gameObject.GetComponent<MeshRenderer>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Component)component2).gameObject.layer = 23;
					}
					Transform[] componentsInChildren = val.gameObject.GetComponentsInChildren<Transform>();
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						((Component)componentsInChildren[i]).gameObject.layer = 23;
					}
				}
				AppliedCosmetics.Add(id, val);
				if (CosmeticsHidden)
				{
					val.SetActive(false);
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)("Player has unsupported cosmetic: " + id));
			}
		}

		public void SaveLocal(bool saveBackup = true)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			if (!ServerConfiguration.Instance.General.SaveProgress)
			{
				return;
			}
			string localSaveFile = GetLocalSaveFile();
			string localSaveFile2 = GetLocalSaveFile(backup: true);
			if (saveBackup)
			{
				try
				{
					if (File.Exists(localSaveFile))
					{
						File.Copy(localSaveFile, localSaveFile2, overwrite: true);
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)"Error while creating backup:");
					Plugin.Log.LogWarning((object)ex);
				}
			}
			Plugin.Log.LogInfo((object)("Saving player data to client save file " + localSaveFile + "."));
			try
			{
				JObject val = new JObject();
				val["xp"] = JToken.op_Implicit(XP);
				JObject val2 = new JObject();
				foreach (KeyValuePair<string, int> level in Levels)
				{
					val2[level.Key] = JToken.op_Implicit(level.Value);
				}
				val["perks"] = (JToken)(object)val2;
				File.WriteAllText(localSaveFile, ((object)val).ToString());
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)"Error while saving:");
				Plugin.Log.LogWarning((object)ex2);
			}
		}

		public void SaveServer(string saveFile)
		{
			if (!ServerConfiguration.Instance.General.SaveProgress)
			{
				string text = Controller.playerUsername;
				if (SteamID != 0)
				{
					text = SteamID.ToString() ?? "";
				}
				Plugin.Log.LogInfo((object)("Saving player data for username " + text + " to server save file " + saveFile + "."));
				ES3.Save<int>("PlayerXP_" + text, XP, saveFile);
				ES3.Save<Dictionary<string, int>>("PlayerPerks_" + text, Levels, saveFile);
			}
		}

		public void LoadServer(string saveFile)
		{
			if (ServerConfiguration.Instance.General.SaveProgress)
			{
				return;
			}
			string text = (((Object)(object)Controller == (Object)null) ? "Player #0" : Controller.playerUsername);
			if (SteamID != 0)
			{
				text = SteamID.ToString() ?? "";
			}
			Plugin.Log.LogInfo((object)("Loading player data for " + text + " from server save file " + saveFile + "."));
			if ((Object)(object)Controller == (Object)null || ServerConfiguration.Instance.General.IndividualXP)
			{
				if (ES3.KeyExists("PlayerXP_" + text, saveFile))
				{
					XP = ES3.Load<int>("PlayerXP_" + text, saveFile);
				}
				else
				{
					XP = ServerConfiguration.Instance.General.StartingXP;
				}
			}
			else
			{
				XP = AdvancedCompany.Network.Manager.Lobby.ConnectedPlayers[0].XP;
			}
			if (ES3.KeyExists("PlayerPerks_" + text, saveFile))
			{
				Levels = ES3.Load<Dictionary<string, int>>("PlayerPerks_" + text, saveFile);
			}
			else
			{
				Levels = new Dictionary<string, int>();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void Init(PlayerControllerB __instance)
		{
			try
			{
				VisionEnhancerEffect.Initialize();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)ex);
			}
		}

		internal static AnimationClip FindAnimation(string animName)
		{
			AnimationClip[] animationClips = AnimationPatches.PlayerAnimator.animationClips;
			foreach (AnimationClip val in animationClips)
			{
				if (((Object)val).name == animName)
				{
					return val;
				}
			}
			if (AdvancedCompany.Lib.Player.Animations.ContainsKey(animName))
			{
				return AdvancedCompany.Lib.Player.Animations[animName];
			}
			return null;
		}

		public void AddOverride(string originalName, string replacementName, bool syncOverride = false)
		{
			AnimationClip val = FindAnimation(replacementName);
			if ((Object)(object)val != (Object)null)
			{
				AddOverride(originalName, val);
				if (syncOverride)
				{
					AdvancedCompany.Network.Manager.Send(new SyncAnimationOverride
					{
						OriginalName = originalName,
						ReplacementName = replacementName,
						PlayerNum = PlayerNum
					}, 0uL);
				}
			}
			else
			{
				Plugin.Log.LogMessage((object)("Can't find animation " + replacementName));
			}
		}

		public void AddOverride(string originalName, AnimationClip clip)
		{
			RuntimeAnimatorController runtimeAnimatorController = Controller.playerBodyAnimator.runtimeAnimatorController;
			AnimatorOverrideController val = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
			if (val != null)
			{
				if (!OriginalClips.ContainsKey(originalName))
				{
					OriginalClips.Add(originalName, val[originalName]);
				}
				Plugin.Log.LogMessage((object)("Overriding clip " + originalName + " with " + ((Object)clip).name));
				val[originalName] = clip;
			}
			else
			{
				Plugin.Log.LogWarning((object)"Animation controller is not of type AnimatorOverrideController!");
			}
		}

		public void RemoveOverride(string originalName, bool syncOverride = false)
		{
			RuntimeAnimatorController runtimeAnimatorController = Controller.playerBodyAnimator.runtimeAnimatorController;
			AnimatorOverrideController val = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
			if (val != null)
			{
				if (OriginalClips.ContainsKey(originalName))
				{
					Plugin.Log.LogMessage((object)("Restoring animation " + originalName));
					val[originalName] = OriginalClips[originalName];
					if (syncOverride)
					{
						AdvancedCompany.Network.Manager.Send(new SyncAnimationOverride
						{
							OriginalName = originalName,
							ReplacementName = "",
							PlayerNum = PlayerNum
						}, 0uL);
					}
				}
				else
				{
					Plugin.Log.LogWarning((object)("Original clip for " + originalName + " was missing."));
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)"Animation controller is not of type AnimatorOverrideController!");
			}
		}

		internal void NetworkOverride(string originalName, string replacementName)
		{
			RuntimeAnimatorController runtimeAnimatorController = Controller.playerBodyAnimator.runtimeAnimatorController;
			AnimatorOverrideController val = (AnimatorOverrideController)(object)((runtimeAnimatorController is AnimatorOverrideController) ? runtimeAnimatorController : null);
			if (val != null)
			{
				if (replacementName == "")
				{
					if (OriginalClips.ContainsKey(originalName))
					{
						Plugin.Log.LogMessage((object)("Restoring animation " + originalName));
						val[originalName] = OriginalClips[originalName];
					}
					else
					{
						Plugin.Log.LogWarning((object)("Original clip for " + originalName + " was missing."));
					}
					return;
				}
				AnimationClip val2 = FindAnimation(replacementName);
				if ((Object)(object)val2 != (Object)null)
				{
					if (!OriginalClips.ContainsKey(originalName))
					{
						OriginalClips.Add(originalName, val[originalName]);
					}
					Plugin.Log.LogMessage((object)("Overriding clip " + originalName + " with " + ((Object)val2).name));
					val[originalName] = val2;
				}
			}
			else
			{
				Plugin.Log.LogWarning((object)"Animation controller is not of type AnimatorOverrideController!");
			}
		}
	}
	internal class Ship : BaseUpgradeable
	{
		internal int TotalQuota;

		internal bool ExtendedDeadline;

		public override void ReadData(FastBufferReader reader)
		{
			//IL_0002: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			base.ReadData(reader);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref TotalQuota, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ExtendedDeadline, default(ForPrimitives));
		}

		public override void WriteData(FastBufferWriter writer)
		{
			//IL_0002: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			base.WriteData(writer);
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref TotalQuota, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref ExtendedDeadline, default(ForPrimitives));
		}

		public override void Reset(bool resetXP)
		{
			Levels.Clear();
			if (resetXP)
			{
				XP = ServerConfiguration.Instance.General.StartingShipXP;
			}
		}

		public void ResetSave(string saveFile)
		{
			ES3.Save<int>("ShipXP", ServerConfiguration.Instance.General.StartingShipXP, saveFile);
			ES3.Save<Dictionary<string, int>>("Perks", new Dictionary<string, int>(), saveFile);
			ES3.Save<int>("TotalQuota", 0, saveFile);
			ES3.Save<bool>("ExtendedDeadline", false, saveFile);
			string[] keys = ES3.GetKeys(saveFile);
			for (int i = 0; i < keys.Length; i++)
			{
				if (keys[i].StartsWith("PlayerXP_") || keys[i].StartsWith("PlayerPerks_"))
				{
					ES3.DeleteKey(keys[i], saveFile);
				}
			}
		}

		public static Ship Load(string saveFile)
		{
			Ship ship = new Ship();
			if (ES3.KeyExists("ShipXP", saveFile))
			{
				ship.XP = ES3.Load<int>("ShipXP", saveFile);
				if (ES3.KeyExists("Perks", saveFile))
				{
					ship.Levels = ES3.Load<Dictionary<string, int>>("Perks", saveFile);
				}
			}
			else
			{
				ship.XP = ServerConfiguration.Instance.General.StartingShipXP;
			}
			if (ES3.KeyExists("TotalQuota", saveFile))
			{
				ship.TotalQuota = ES3.Load<int>("TotalQuota", saveFile);
			}
			if (ES3.KeyExists("ExtendedDeadline", saveFile))
			{
				ship.ExtendedDeadline = ES3.Load<bool>("ExtendedDeadline", saveFile);
			}
			return ship;
		}

		public void Save(string saveFile)
		{
			ES3.Save<int>("ShipXP", XP, saveFile);
			ES3.Save<Dictionary<string, int>>("Perks", Levels, saveFile);
			ES3.Save<int>("TotalQuota", TotalQuota, saveFile);
			ES3.Save<bool>("ExtendedDeadline", ExtendedDeadline, saveFile);
		}

		public void Log()
		{
			foreach (KeyValuePair<string, int> level in Levels)
			{
				Plugin.Log.LogMessage((object)(level.Key + ": " + level.Value));
			}
		}
	}
	public class ItemData : MonoBehaviour
	{
		public int ID;

		public string ItemName;

		public Sprite ItemIcon;

		public float Weight;

		public bool IsConductive;

		public bool IsTwoHanded;

		public bool IsScrap;

		public int MinValue;

		public int MaxValue;

		public int Rarity = 100;

		public bool LimitPlanets;

		public int[] PlanetRarities = new int[9];

		public bool UsesBattery;

		public float BatteryUsage;

		public bool IsBuyable;

		public int Price;

		public int MaxDiscount;

		public AudioClip GrabSFX;

		public AudioClip DropSFX;

		public AudioClip PocketSFX;

		public string HoldAnimation;

		public bool HoldIsTwoHanded;

		public bool HasSaveData;

		public bool SyncUseFunction;

		public bool SyncInteractLRFunction;

		public bool SyncGrabFunction;

		public bool SyncDiscardFunction;

		public Vector3 EgoHeldPosition;

		public Vector3 EgoHeldRotation;

		public Vector3 HeldPosition;

		public Vector3 HeldRotation;

		public Vector3 GroundRestingRotation;

		public float GroundVerticalOffset;

		public Vector3 HolderRestingRotation;

		public Vector3 NoPosition;
	}
	public static class Moons
	{
		public const int Count = 9;

		public const int COMPANY_BUILDING = 0;

		public const int EXPERIMENTATION = 1;

		public const int VOW = 2;

		public const int ASSURANCE = 3;

		public const int OFFENSE = 4;

		public const int MARCH = 5;

		public const int REND = 6;

		public const int DINE = 7;

		public const int TITAN = 8;
	}
}
namespace AdvancedCompany.Config
{
	[Bootable]
	internal class ClientConfiguration : PlayerConfiguration
	{
		public class KeybindsConfig : LcInputActions
		{
			[InputAction("<Keyboard>/1", Name = "Inventory slot 1")]
			public InputAction InventorySlot1 { get; set; }

			[InputAction("<Keyboard>/2", Name = "Inventory slot 2")]
			public InputAction InventorySlot2 { get; set; }

			[InputAction("<Keyboard>/3", Name = "Inventory slot 3")]
			public InputAction InventorySlot3 { get; set; }

			[InputAction("<Keyboard>/4", Name = "Inventory slot 4")]
			public InputAction InventorySlot4 { get; set; }

			[InputAction("<Keyboard>/5", Name = "Inventory slot 5")]
			public InputAction InventorySlot5 { get; set; }

			[InputAction("<Keyboard>/6", Name = "Inventory slot 6")]
			public InputAction InventorySlot6 { get; set; }

			[InputAction("<Keyboard>/7", Name = "Inventory slot 7")]
			public InputAction InventorySlot7 { get; set; }

			[InputAction("<Keyboard>/8", Name = "Inventory slot 8")]
			public InputAction InventorySlot8 { get; set; }

			[InputAction("<Keyboard>/9", Name = "Inventory slot 9")]
			public InputAction InventorySlot9 { get; set; }

			[InputAction("<Keyboard>/0", Name = "Inventory slot 10")]
			public InputAction InventorySlot10 { get; set; }

			[InputAction("<Keyboard>/f", Name = "Flashlight")]
			public InputAction Flashlight { get; set; }

			[InputAction("<Keyboard>/v", Name = "Equipment comms")]
			public InputAction Communications { get; set; }

			[InputAction("<Keyboard>/alt", Name = "Switch to equipment")]
			public InputAction Equipment { get; set; }

			[InputAction("<Keyboard>/x", Name = "Portable terminal")]
			public InputAction PortableTerminal { get; set; }
		}

		public static KeybindsConfig Keybinds = new KeybindsConfig();

		public static ClientConfiguration Instance;

		public static float GetHotbarAlpha()
		{
			return Instance.Hotbar.HotbarAlpha;
		}

		public static void Boot()
		{
			Instance = new ClientConfiguration();
		}
	}
	[Requires(typeof(ClientConfiguration))]
	[Bootable]
	internal class ClientConfigurationProvider : BaseSettings<PlayerConfiguration>.IConfigurationProvider
	{
		internal static ClientConfigurationProvider Instance;

		private List<BaseSettings<PlayerConfiguration>.Preset> Presets = new List<BaseSettings<PlayerConfiguration>.Preset>();

		private BaseSettings<PlayerConfiguration>.Preset FilePreset;

		public string Directory => Path.Combine(Paths.ConfigPath, "../", "presets", "advancedcompany", "client");

		public static void Boot()
		{
			Instance = new ClientConfigurationProvider();
		}

		public ClientConfigurationProvider()
		{
			PlayerConfiguration playerConfiguration = new PlayerConfiguration();
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string[] files = System.IO.Directory.GetFiles(Directory);
			string[] array = files;
			foreach (string text in array)
			{
				if (Path.GetExtension(text) == ".preset")
				{
					try
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
						PlayerConfiguration playerConfiguration2 = new PlayerConfiguration();
						playerConfiguration2.Build();
						string text2 = File.ReadAllText(text);
						JObject obj = JObject.Parse(text2);
						playerConfiguration2.FromJSON(obj);
						Presets.Add(new BaseSettings<PlayerConfiguration>.Preset(this, fileNameWithoutExtension, playerConfiguration2));
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error while loading client preset \"" + text + "\":"));
						Plugin.Log.LogError((object)ex);
					}
				}
			}
			if (Presets.Count == 0)
			{
				Presets.Add(new BaseSettings<PlayerConfiguration>.Preset(this, "Default", new PlayerConfiguration(), canRemove: false, canRename: false));
			}
		}

		public BaseSettings<PlayerConfiguration>.Preset CreatePreset(string name, PlayerConfiguration configuration)
		{
			BaseSettings<PlayerConfiguration>.Preset preset = new BaseSettings<PlayerConfiguration>.Preset(this, name, configuration);
			Presets.Add(preset);
			return preset;
		}

		public List<BaseSettings<PlayerConfiguration>.Preset> GetPresets()
		{
			return Presets;
		}

		public void PresetCreated(BaseSettings<PlayerConfiguration>.Preset preset)
		{
			PresetSaved(preset);
		}

		public void PresetRemoved(BaseSettings<PlayerConfiguration>.Preset preset)
		{
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string path = Path.Combine(Directory, preset.Name + ".preset");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			Presets.Remove(preset);
		}

		public void PresetRenamed(BaseSettings<PlayerConfiguration>.Preset preset, string oldName, string newName)
		{
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string sourceFileName = Path.Combine(Directory, oldName + ".preset");
			string destFileName = Path.Combine(Directory, newName + ".preset");
			File.Move(sourceFileName, destFileName);
		}

		public void PresetSaved(BaseSettings<PlayerConfiguration>.Preset preset)
		{
			string contents = ((JToken)preset.Configuration.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>());
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string path = Path.Combine(Directory, preset.Name + ".preset");
			File.WriteAllText(path, contents);
		}

		public BaseSettings<PlayerConfiguration>.Preset GetPreset(string name)
		{
			for (int i = 0; i < Presets.Count; i++)
			{
				if (Presets[i].Name.Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					return Presets[i];
				}
			}
			return null;
		}
	}
	internal static class ConfigurationExtension
	{
	}
	internal static class JObjectExtensions
	{
		public static bool TryGetFloat(this JObject obj, string key, out float val)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			JToken val2 = default(JToken);
			if (obj.TryGetValue(key, ref val2))
			{
				JValue val3 = (JValue)(object)((val2 is JValue) ? val2 : null);
				if (val3 != null)
				{
					if ((int)((JToken)val3).Type == 7)
					{
						if (val3.Value is float num)
						{
							val = num;
							return true;
						}
						if (val3.Value is double num2)
						{
							val = (float)num2;
							return true;
						}
					}
					if (float.TryParse(val3.ToString((IFormatProvider)CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
					{
						val = result;
						return true;
					}
				}
			}
			val = 0f;
			return false;
		}

		public static bool TryGetInt(this JObject obj, string key, out int val)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			JToken val2 = default(JToken);
			if (obj.TryGetValue(key, ref val2))
			{
				JValue val3 = (JValue)(object)((val2 is JValue) ? val2 : null);
				if (val3 != null)
				{
					if ((int)((JToken)val3).Type == 6 && val3.Value is int num)
					{
						val = num;
						return true;
					}
					if (int.TryParse(((object)val3).ToString(), out var result))
					{
						val = result;
						return true;
					}
				}
			}
			val = 0;
			return false;
		}
	}
	internal class JSONSerializer
	{
	}
	[Bootable]
	[Requires(typeof(ServerConfiguration))]
	internal class LobbyConfigurationProvider : BaseSettings<LobbyConfiguration>.IConfigurationProvider
	{
		internal static LobbyConfigurationProvider Instance;

		private List<BaseSettings<LobbyConfiguration>.Preset> Presets = new List<BaseSettings<LobbyConfiguration>.Preset>();

		private BaseSettings<LobbyConfiguration>.Preset FilePreset;

		public string PredefinedPresetsDirectory => Path.Combine(Path.GetDirectoryName(typeof(LobbyConfigurationProvider).Assembly.Location), "presets");

		public string Directory => Path.Combine(Paths.ConfigPath, "advancedcompany", "presets", "server");

		public static void Boot()
		{
			Instance = new LobbyConfigurationProvider();
		}

		public LobbyConfigurationProvider()
		{
			string[] array = null;
			if (ModpackConfig.Instance.ShowDefaultPresets.Value)
			{
				if (!System.IO.Directory.Exists(PredefinedPresetsDirectory))
				{
					System.IO.Directory.CreateDirectory(PredefinedPresetsDirectory);
				}
				array = System.IO.Directory.GetFiles(PredefinedPresetsDirectory);
				string[] array2 = array;
				foreach (string text in array2)
				{
					try
					{
						string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
						LobbyConfiguration lobbyConfiguration = new LobbyConfiguration();
						lobbyConfiguration.Build();
						string text2 = File.ReadAllText(text);
						JObject obj = JObject.Parse(text2);
						lobbyConfiguration.FromJSON(obj);
						Presets.Add(new BaseSettings<LobbyConfiguration>.Preset(this, fileNameWithoutExtension, lobbyConfiguration, canRemove: false, canRename: false, canBeSaved: false));
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Error while loading lobby preset \"" + text + "\":"));
						Plugin.Log.LogError((object)ex);
					}
				}
				Presets = Presets.OrderBy((BaseSettings<LobbyConfiguration>.Preset x) => (x.Name == "Default") ? "aa" : x.Name).ToList();
			}
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			array = System.IO.Directory.GetFiles(Directory);
			string[] array3 = array;
			foreach (string text3 in array3)
			{
				if (Path.GetExtension(text3) == ".json")
				{
					try
					{
						string fileNameWithoutExtension2 = Path.GetFileNameWithoutExtension(text3);
						LobbyConfiguration lobbyConfiguration2 = new LobbyConfiguration();
						lobbyConfiguration2.Build();
						string text4 = File.ReadAllText(text3);
						JObject obj2 = JObject.Parse(text4);
						lobbyConfiguration2.FromJSON(obj2);
						Presets.Add(new BaseSettings<LobbyConfiguration>.Preset(this, fileNameWithoutExtension2, lobbyConfiguration2));
					}
					catch (Exception ex2)
					{
						Plugin.Log.LogError((object)("Error while loading lobby preset \"" + text3 + "\":"));
						Plugin.Log.LogError((object)ex2);
					}
				}
			}
			if (Presets.Count == 0)
			{
				Presets.Add(new BaseSettings<LobbyConfiguration>.Preset(this, "Default", new LobbyConfiguration(), canRemove: false, canRename: false));
			}
		}

		public BaseSettings<LobbyConfiguration>.Preset CreatePreset(string name, LobbyConfiguration configuration)
		{
			BaseSettings<LobbyConfiguration>.Preset preset = new BaseSettings<LobbyConfiguration>.Preset(this, name, configuration);
			Presets.Add(preset);
			return preset;
		}

		public List<BaseSettings<LobbyConfiguration>.Preset> GetPresets()
		{
			return Presets;
		}

		public void PresetCreated(BaseSettings<LobbyConfiguration>.Preset preset)
		{
			PresetSaved(preset);
		}

		public void PresetRemoved(BaseSettings<LobbyConfiguration>.Preset preset)
		{
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string path = Path.Combine(Directory, preset.Name + ".json");
			if (File.Exists(path))
			{
				File.Delete(path);
			}
			Presets.Remove(preset);
		}

		public void PresetRenamed(BaseSettings<LobbyConfiguration>.Preset preset, string oldName, string newName)
		{
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string sourceFileName = Path.Combine(Directory, oldName + ".json");
			string destFileName = Path.Combine(Directory, newName + ".json");
			File.Move(sourceFileName, destFileName);
		}

		public void PresetSaved(BaseSettings<LobbyConfiguration>.Preset preset)
		{
			string contents = ((JToken)preset.Configuration.ToJSON()).ToString((Formatting)1, Array.Empty<JsonConverter>());
			if (!System.IO.Directory.Exists(Directory))
			{
				System.IO.Directory.CreateDirectory(Directory);
			}
			string path = Path.Combine(Directory, preset.Name + ".json");
			File.WriteAllText(path, contents);
		}

		public BaseSettings<LobbyConfiguration>.Preset GetPreset(string name)
		{
			for (int i = 0; i < Presets.Count; i++)
			{
				if (Presets[i].Name.Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					return Presets[i];
				}
			}
			return null;
		}
	}
	internal class ModpackConfig
	{
		internal static ModpackConfig Instance;

		internal ConfigFile File;

		internal ConfigEntry<string> LogoFilename;

		internal ConfigEntry<bool> ShowDefaultPresets;

		internal ConfigEntry<string> StandardPreset;

		internal ConfigEntry<bool> SkipPresets;

		static ModpackConfig()
		{
			Instance = new ModpackConfig();
		}

		internal ModpackConfig()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0058: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_0089: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00be: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00ef: Expected O, but got Unknown
			File = new ConfigFile(Path.Combine(Paths.ConfigPath, "advancedcompany", "ModPack.cfg"), true);
			LogoFilename = File.Bind<string>(new ConfigDefinition("Logo", "Image filename"), "Logo.png", new ConfigDescription("The image filename AC should look for when searching for a custom menu logo image.", (AcceptableValueBase)null, Array.Empty<object>()));
			ShowDefaultPresets = File.Bind<bool>(new ConfigDefinition("Presets", "Show default"), true, new ConfigDescription("If the standard presets \"Default\", \"Alternative\" and \"Vanilla\" should be shown.", (AcceptableValueBase)null, Array.Empty<object>()));
			StandardPreset = File.Bind<string>(new ConfigDefinition("Presets", "Standard"), "Default", new ConfigDescription("The name of the preset which should be selected for a new save file.", (AcceptableValueBase)null, Array.Empty<object>()));
			SkipPresets = File.Bind<bool>(new ConfigDefinition("Presets", "Skip presets"), false, new ConfigDescription("Automatically selects the standard preset and skips the setup screen of AC when activated.", (AcceptableValueBase)null, Array.Empty<object>()));
		}
	}
	[Bootable]
	internal class ServerConfiguration : LobbyConfiguration
	{
		public static ServerConfiguration Instance;

		public void WasLoaded()
		{
			if (General.DeactivateHotbar)
			{
				Plugin.Log.LogError((object)"╔══════════════════════════════════════════════════╗");
				Plugin.Log.LogError((object)"║ HOTBAR CHANGES DEACTIVATED!                      ║");
				Plugin.Log.LogError((object)"╟──────────────────────────────────────────────────╢");
				Plugin.Log.LogError((object)"║ This notice serves as an indicator that you or   ║");
				Plugin.Log.LogError((object)"║ the host of the game you've joined have          ║");
				Plugin.Log.LogError((object)"║ deactivated a core module of AdvancedCompany and ║");
				Plugin.Log.LogError((object)"║ won't get support or help from AdvancedCompanys  ║");
				Plugin.Log.LogError((object)"║ developer nor are eligible to submit issues on   ║");
				Plugin.Log.LogError((object)"║ AdvancedCompanys GitHub repository.              ║");
				Plugin.Log.LogError((object)"╟──────────────────────────────────────────────────╢");
				Plugin.Log.LogError((object)"║ Removing this notice and opening an issue will   ║");
				Plugin.Log.LogError((object)"║ result in a block on GitHub.                     ║");
				Plugin.Log.LogError((object)"╚══════════════════════════════════════════════════╝");
				Items.Items["Headset"].Active = false;
				Items.Items["Tactical helmet"].Active = false;
				Items.Items["Helmet lamp"].Active = false;
				Items.Items["Vision enhancer"].Active = false;
				Items.Items["Flippers"].Active = false;
				Items.Items["Rocket boots"].Active = false;
				Items.Items["Bulletproof vest"].Active = false;
				Items.Scrap["Light shoes"].Active = false;
				Items.Scrap["Bunny ears"].Active = false;
				PlayerPerks.InventorySlots.Active = false;
			}
		}

		public static void Boot()
		{
			string path = Path.Combine(Paths.ConfigPath, "advancedcompany", "moons.json");
			string path2 = Path.Combine(Paths.ConfigPath, "advancedcompany", "items.json");
			string path3 = Path.Combine(Paths.ConfigPath, "advancedcompany", "enemies.json");
			string path4 = Path.Combine(Paths.ConfigPath, "advancedcompany", "scrap.json");
			string path5 = Path.Combine(Paths.ConfigPath, "advancedcompany", "unlockables.json");
			if (File.Exists(path2))
			{
				try
				{
					LobbyConfiguration.AllItemsConfig.FromJSON(JObject.Parse(File.ReadAllText(path2)), setDefault: true);
					LobbyConfiguration.AllItemsConfig.Build();
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)"Error while loading items:");
					Plugin.Log.LogError((object)ex);
				}
			}
			if (File.Exists(path3))
			{
				try
				{
					LobbyConfiguration.AllEnemiesConfig.FromJSON(JObject.Parse(File.ReadAllText(path3)), setDefault: true);
					LobbyConfiguration.AllEnemiesConfig.Build();
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogError((object)"Error while loading enemies:");
					Plugin.Log.LogError((object)ex2);
				}
			}
			if (File.Exists(path4))
			{
				try
				{
					LobbyConfiguration.AllScrapConfig.FromJSON(JObject.Parse(File.ReadAllText(path4)), setDefault: true);
					LobbyConfiguration.AllScrapConfig.Build();
				}
				catch (Exception ex3)
				{
					Plugin.Log.LogError((object)"Error while loading scrap:");
					Plugin.Log.LogError((object)ex3);
				}
			}
			if (File.Exists(path5))
			{
				try
				{
					LobbyConfiguration.AllUnlockablesConfig.FromJSON(JObject.Parse(File.ReadAllText(path5)), setDefault: true);
					LobbyConfiguration.AllUnlockablesConfig.Build();
				}
				catch (Exception ex4)
				{
					Plugin.Log.LogError((object)"Error while loading unlockables:");
					Plugin.Log.LogError((object)ex4);
				}
			}
			if (File.Exists(path))
			{
				try
				{
					LobbyConfiguration.AllMoonsConfig.FromJSON(JObject.Parse(File.ReadAllText(path)), setDefault: true);
					foreach (KeyValuePair<string, MoonConfig> moon in LobbyConfiguration.AllMoonsConfig.Moons)
					{
						foreach (KeyValuePair<string, ScrapConfig> item in LobbyConfiguration.AllScrapConfig.Items)
						{
							if (!moon.Value.LootTable.ContainsKey(item.Key))
							{
								moon.Value.LootTable.Add(item.Key, new MoonConfig.LootTableItem
								{
									Override = false,
									Rarity = 0
								});
							}
						}
						foreach (KeyValuePair<string, EnemyConfig> enemy in LobbyConfiguration.AllEnemiesConfig.Enemies)
						{
							if (!moon.Value.DaytimeEnemies.ContainsKey(enemy.Key))
							{
								moon.Value.DaytimeEnemies.Add(enemy.Key, new MoonConfig.EnemyTableItem
								{
									Override = false,
									Rarity = 0
								});
							}
							if (!moon.Value.OutsideEnemies.ContainsKey(enemy.Key))
							{
								moon.Value.OutsideEnemies.Add(enemy.Key, new MoonConfig.EnemyTableItem
								{
									Override = false,
									Rarity = 0
								});
							}
							if (!moon.Value.InsideEnemies.ContainsKey(enemy.Key))
							{
								moon.Value.InsideEnemies.Add(enemy.Key, new MoonConfig.EnemyTableItem
								{
									Override = false,
									Rarity = 0
								});
							}
						}
					}
					LobbyConfiguration.AllMoonsConfig.Build();
				}
				catch (Exception ex5)
				{
					Plugin.Log.LogError((object)"Error while loading moons:");
					Plugin.Log.LogError((object)ex5);
				}
			}
			Instance = new ServerConfiguration();
		}
	}
	public class AllEnemies : Configuration
	{
		public Dictionary<string, LobbyConfiguration.EnemyConfig> Enemies = new Dictionary<string, LobbyConfiguration.EnemyConfig>();
	}
	public class AllItems : Configuration
	{
		public Dictionary<string, LobbyConfiguration.ItemConfig> Items = new Dictionary<string, LobbyConfiguration.ItemConfig>();
	}
	internal class AllMoons : Configuration
	{
		public Dictionary<string, LobbyConfiguration.MoonConfig> Moons = new Dictionary<string, LobbyConfiguration.MoonConfig>();
	}
	public class AllScrap : Configuration
	{
		public Dictionary<string, LobbyConfiguration.ScrapConfig> Items = new Dictionary<string, LobbyConfiguration.ScrapConfig>();
	}
	public class AllUnlockables : Configuration
	{
		public Dictionary<string, LobbyConfiguration.UnlockableConfig> Unlockables = new Dictionary<string, LobbyConfiguration.UnlockableConfig>();
	}
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
	public class Slider : Attribute
	{
		public float MinValue;

		public float MaxValue;

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


		public bool ShowValue { get; set; } = false;


		public float InputWidth { get; set; } = 35f;


		public Slider(float minValue, float maxValue)
		{
			MinValue = minValue;
			MaxValue = maxValue;
		}
	}
	public abstract class Configuration
	{
		public class ConfigField
		{
			public Configuration Configuration;

			internal FieldDescriptor Field;

			public object DefaultValue;

			public object Value
			{
				get
				{
					return Field.Field.GetValue(Configuration);
				}
				set
				{
					Field.Field.SetValue(Configuration, value);
				}
			}

			internal ConfigField(Configuration configuration, FieldDescriptor descriptor)
			{
				Configuration = configuration;
				Field = descriptor;
				object obj = descriptor.Field.GetValue(Configuration);
				if (typeof(Configuration).IsAssignableFrom(descriptor.Field.FieldType))
				{
					if (obj == null)
					{
						obj = Activator.CreateInstance(descriptor.Field.FieldType);
					}
					if (obj is Configuration configuration2)
					{
						configuration2.Build();
					}
				}
				else
				{
					if (obj == null && Field.Field.FieldType != typeof(string))
					{
						obj = ((!Field.Field.FieldType.IsArray) ? Activator.CreateInstance(Field.Field.FieldType) : Array.CreateInstance(Field.Field.FieldType.GetElementType(), 0));
					}
					DefaultValue = DeepClone(obj);
				}
			}

			public void Reset()
			{
				if (Value is Configuration)
				{
					throw new ArgumentException("Can't clone configuration values!");
				}
				Value = CloneDefault();
			}

			public object CloneValue()
			{
				if (Value is Configuration)
				{
					throw new ArgumentException("Can't clone configuration values!");
				}
				return DeepClone(Value);
			}

			public object CloneDefault()
			{
				if (!typeof(Configuration).IsAssignableFrom(Field.Field.FieldType))
				{
					Configuration configuration = DefaultValue as Configuration;
					if (configuration == null)
					{
						return DeepClone(DefaultValue);
					}
				}
				throw new ArgumentException("Can't clone configuration values!");
			}
		}

		internal class FieldDescriptor
		{
			public FieldInfo Field;

			public string JSONName;

			public BaseConverter Converter;

			public Slider SliderAttribute;

			public FieldDescriptor(FieldInfo fieldInfo)
			{
				Field = fieldInfo;
				SliderAttribute = fieldInfo.GetCustomAttribute<Slider>();
				string name = fieldInfo.Name;
				string text = "";
				bool flag = false;
				for (int i = 0; i < name.Length; i++)
				{
					bool flag2 = (name[i].ToString() ?? "") != (name[i].ToString() ?? "").ToLowerInvariant();
					text = ((i <= 0 || !(!flag && flag2)) ? (text + (name[i].ToString() ?? "").ToLowerInvariant()) : (text + ("_" + name[i]).ToLowerInvariant()));
					flag = flag2;
				}
				JSONName = text;
			}

			public FieldDescriptor(FieldInfo fieldInfo, BaseConverter converter)
				: this(fieldInfo)
			{
				Converter = converter;
			}
		}

		internal List<ConfigField> Fields;

		internal static Dictionary<Type, List<FieldDescriptor>> AllFields = new Dictionary<Type, List<FieldDescriptor>>();

		public void Build()
		{
			if (Fields == null)
			{
				Fields = GetFields(this);
			}
		}

		public void SetDefault(string fieldName, object value)
		{
			ConfigField configField = Field(fieldName);
			if (configField != null)
			{
				configField.DefaultValue = DeepClone(value);
			}
		}

		protected virtual void SetDefaults()
		{
			Type type = GetType();
			List<ConfigField> list = new List<ConfigField>();
			foreach (FieldDescriptor item in AllFields[type])
			{
				list.Add(new ConfigField(this, item));
			}
			Fields = list;
		}

		internal static object DeepClone(object obj)
		{
			if (obj == null)
			{
				return null;
			}
			Type type = obj.GetType();
			if (type.IsValueType || type == typeof(string))
			{
				return obj;
			}
			if (obj is Array array)
			{
				Array array2 = Array.CreateInstance(type.GetElementType(), array.Length);
				for (int i = 0; i < array.Length; i++)
				{
					array2.SetValue(DeepClone(array.GetValue(i)), i);
				}
				return array2;
			}
			if (obj is Configuration configuration)
			{
				Configuration configuration2 = configuration._Clone();
				configuration2.Build();
				return configuration2;
			}
			object obj2 = Activator.CreateInstance(type);
			if (obj is IList list && obj2 is IList list2)
			{
				foreach (object item in list)
				{
					list2.Add(DeepClone(item));
				}
				return list2;
			}
			if (obj is IDictionary dictionary && obj2 is IDictionary dictionary2)
			{
				foreach (object key in dictionary.Keys)
				{
					dictionary2.Add(DeepClone(key), DeepClone(dictionary[key]));
				}
				return dictionary2;
			}
			throw new Exception("Cant clone " + type.FullName);
		}

		public Configuration()
		{
		}

		internal virtual Configuration _Clone()
		{
			Configuration configuration = (Configuration)Activator.CreateInstance(GetType());
			configuration._CopyFrom(this);
			return configuration;
		}

		internal static List<ConfigField> GetFields(Configuration instance)
		{
			if (instance.Fields != null)
			{
				return instance.Fields;
			}
			Type type = instance.GetType();
			if (!AllFields.ContainsKey(type))
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
				List<FieldDescriptor> list = new List<FieldDescriptor>();
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					BaseConverter converter = BaseConverter.GetConverter(fieldInfo.FieldType);
					if (converter != null)
					{
						list.Add(new FieldDescriptor(fieldInfo, converter));
					}
				}
				AllFields[type] = list;
			}
			instance.SetDefaults();
			return instance.Fields;
		}

		public ConfigField Field(string fieldName)
		{
			for (int i = 0; i < Fields.Count; i++)
			{
				if (Fields[i].Field.Field.Name == fieldName)
				{
					return Fields[i];
				}
			}
			return null;
		}

		public virtual object Default(string fieldName)
		{
			for (int i = 0; i < Fields.Count; i++)
			{
				if (Fields[i].Field.Field.Name == fieldName)
				{
					return Fields[i].DefaultValue;
				}
			}
			return null;
		}

		public virtual void Reset(string fieldName)
		{
			for (int i = 0; i < Fields.Count; i++)
			{
				if (Fields[i].Field.Field.Name == fieldName)
				{
					Fields[i].Reset();
					break;
				}
			}
		}

		public virtual void Reset()
		{
			for (int i = 0; i < Fields.Count; i++)
			{
				Fields[i].Reset();
			}
		}

		public virtual void CopyFrom(Configuration configuration)
		{
			_CopyFrom(configuration);
		}

		internal static Type FindCommonType(Type typeA, Type typeB)
		{
			if (typeA == typeB)
			{
				return typeA;
			}
			Type baseType = typeA.BaseType;
			while (baseType != null)
			{
				if (baseType == typeB)
				{
					return baseType;
				}
				baseType = baseType.BaseType;
			}
			Type baseType2 = typeB.BaseType;
			while (baseType2 != null)
			{
				if (baseType2 == typeA)
				{
					return baseType2;
				}
				baseType2 = baseType2.BaseType;
			}
			return null;
		}

		internal virtual void _CopyFrom(Configuration configuration, bool copyDefault = true)
		{
			Type type = FindCommonType(GetType(), configuration.GetType());
			if (type != null)
			{
				List<ConfigField> fields = GetFields(this);
				List<ConfigField> fields2 = GetFields(configuration);
				for (int i = 0; i < fields.Count; i++)
				{
					for (int j = 0; j < fields2.Count; j++)
					{
						if (!(fields[i].Field.Field.Name == fields2[j].Field.Field.Name))
						{
							continue;
						}
						if (fields[i].Value is Configuration configuration2 && fields2[j].Value is Configuration configuration3)
						{
							configuration2._CopyFrom(configuration3, copyDefault);
							break;
						}
						if (copyDefault)
						{
							fields[i].DefaultValue = fields2[j].CloneDefault();
						}
						fields[i].Value = fields2[j].CloneValue();
						break;
					}
				}
				return;
			}
			throw new Exception("Only same types can be copied.");
		}

		public virtual void WriteData(FastBufferWriter writer)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			BaseConverter converter = BaseConverter.GetConverter(GetType());
			converter._Write(writer, this);
		}

		public virtual void ReadData(FastBufferReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			BaseConverter converter = BaseConverter.GetConverter(GetType());
			Configuration configuration = (Configuration)converter._Read(reader, GetType());
			_CopyFrom(configuration, copyDefault: false);
		}

		public virtual void LoadedFromJSON()
		{
		}

		public virtual JObject ToJSON()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			BaseConverter converter = BaseConverter.GetConverter(GetType());
			return (JObject)converter._ToJSON(this);
		}

		public virtual void FromJSON(JObject obj, bool setDefault = false)
		{
			BaseConverter converter = BaseConverter.GetConverter(GetType());
			Configuration configuration = (Configuration)converter._FromJSON((JToken)(object)obj, GetType());
			_CopyFrom(configuration, setDefault);
		}
	}
	public abstract class BaseConverter
	{
		internal static Dictionary<Type, BaseConverter> Converters;

		static BaseConverter()
		{
			Converters = new Dictionary<Type, BaseConverter>();
			AddType(new DelegateConverter<bool>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				bool result12 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref result12, default(ForPrimitives));
				return result12;
			}, delegate(FastBufferWriter writer, bool val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<bool>(), (bool val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<sbyte>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				sbyte result11 = default(sbyte);
				((FastBufferReader)(ref reader)).ReadValueSafe<sbyte>(ref result11, default(ForPrimitives));
				return result11;
			}, delegate(FastBufferWriter writer, sbyte val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<sbyte>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<sbyte>(), (sbyte val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<byte>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				byte result10 = default(byte);
				((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref result10, default(ForPrimitives));
				return result10;
			}, delegate(FastBufferWriter writer, byte val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<byte>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<byte>(), (byte val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<short>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				short result9 = default(short);
				((FastBufferReader)(ref reader)).ReadValueSafe<short>(ref result9, default(ForPrimitives));
				return result9;
			}, delegate(FastBufferWriter writer, short val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<short>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<short>(), (short val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<ushort>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				ushort result8 = default(ushort);
				((FastBufferReader)(ref reader)).ReadValueSafe<ushort>(ref result8, default(ForPrimitives));
				return result8;
			}, delegate(FastBufferWriter writer, ushort val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<ushort>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<ushort>(), (ushort val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<int>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				int result7 = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result7, default(ForPrimitives));
				return result7;
			}, delegate(FastBufferWriter writer, int val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<int>(), (int val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<uint>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				uint result6 = default(uint);
				((FastBufferReader)(ref reader)).ReadValueSafe<uint>(ref result6, default(ForPrimitives));
				return result6;
			}, delegate(FastBufferWriter writer, uint val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<uint>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<uint>(), (uint val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<long>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				long result5 = default(long);
				((FastBufferReader)(ref reader)).ReadValueSafe<long>(ref result5, default(ForPrimitives));
				return result5;
			}, delegate(FastBufferWriter writer, long val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<long>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<long>(), (long val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<ulong>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				ulong result4 = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref result4, default(ForPrimitives));
				return result4;
			}, delegate(FastBufferWriter writer, ulong val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<ulong>(), (ulong val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<float>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				float result3 = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref result3, default(ForPrimitives));
				return result3;
			}, delegate(FastBufferWriter writer, float val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<float>(), (float val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<double>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				double result2 = default(double);
				((FastBufferReader)(ref reader)).ReadValueSafe<double>(ref result2, default(ForPrimitives));
				return result2;
			}, delegate(FastBufferWriter writer, double val)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				((FastBufferWriter)(ref writer)).WriteValueSafe<double>(ref val, default(ForPrimitives));
			}, (JToken token, Type type) => token.ToObject<double>(), (double val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<string>(delegate(FastBufferReader reader, Type type)
			{
				string result = default(string);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref result, false);
				return result;
			}, delegate(FastBufferWriter writer, string val)
			{
				((FastBufferWriter)(ref writer)).WriteValueSafe(val, false);
			}, (JToken token, Type type) => token.ToObject<string>(), (string val) => JToken.FromObject((object)val)));
			AddType(new DelegateConverter<IDictionary>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				Type[] genericArguments8 = type.GetGenericArguments();
				if (genericArguments8.Length < 2)
				{
					throw new Exception("Unsupported dictionary given. Missing generics.");
				}
				BaseConverter converter12 = GetConverter(genericArguments8[0]);
				BaseConverter converter13 = GetConverter(genericArguments8[1]);
				IDictionary dictionary2 = (IDictionary)Activator.CreateInstance(type);
				int num3 = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num3, default(ForPrimitives));
				for (int n = 0; n < num3; n++)
				{
					object key2 = converter12._Read(reader, genericArguments8[0]);
					object value4 = converter13._Read(reader, genericArguments8[1]);
					dictionary2.Add(key2, value4);
				}
				return dictionary2;
			}, delegate(FastBufferWriter writer, IDictionary val)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: 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)
				Type type11 = val.GetType();
				Type[] genericArguments7 = type11.GetGenericArguments();
				if (genericArguments7.Length < 2)
				{
					throw new Exception("Unsupported dictionary given. Missing generics.");
				}
				BaseConverter converter10 = GetConverter(genericArguments7[0]);
				BaseConverter converter11 = GetConverter(genericArguments7[1]);
				int count2 = val.Count;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count2, default(ForPrimitives));
				foreach (object key3 in val.Keys)
				{
					converter10._Write(writer, key3);
					converter11._Write(writer, val[key3]);
				}
			}, delegate(JToken token, Type type)
			{
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				JArray val8 = (JArray)(object)((token is JArray) ? token : null);
				JTokenType type10;
				if (val8 == null)
				{
					type10 = token.Type;
					throw new Exception("JSON format invalid. Expected array, got " + ((object)(JTokenType)(ref type10)).ToString());
				}
				Type[] genericArguments6 = type.GetGenericArguments();
				if (genericArguments6.Length < 2)
				{
					throw new Exception("Unsupported dictionary given. Missing generics.");
				}
				BaseConverter converter8 = GetConverter(genericArguments6[0]);
				BaseConverter converter9 = GetConverter(genericArguments6[1]);
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				for (int m = 0; m < ((JContainer)val8).Count; m++)
				{
					JToken obj = val8[m];
					JObject val9 = (JObject)(object)((obj is JObject) ? obj : null);
					if (val9 == null || !val9.ContainsKey("key") || !val9.ContainsKey("value"))
					{
						type10 = val8[m].Type;
						throw new Exception("JSON format invalid. Expected object, got " + ((object)(JTokenType)(ref type10)).ToString());
					}
					object key = converter8._FromJSON(val9["key"], genericArguments6[0]);
					object value3 = converter9._FromJSON(val9["value"], genericArguments6[1]);
					dictionary.Add(key, value3);
				}
				return dictionary;
			}, delegate(IDictionary val)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				Type type9 = val.GetType();
				Type[] genericArguments5 = type9.GetGenericArguments();
				if (genericArguments5.Length < 2)
				{
					throw new Exception("Unsupported dictionary given. Missing generics.");
				}
				BaseConverter converter6 = GetConverter(genericArguments5[0]);
				BaseConverter converter7 = GetConverter(genericArguments5[1]);
				JArray val6 = new JArray();
				foreach (object key4 in val.Keys)
				{
					JObject val7 = new JObject();
					val7["key"] = converter6._ToJSON(key4);
					val7["value"] = converter7._ToJSON(val[key4]);
					val6.Add((JToken)(object)val7);
				}
				return (JToken)(object)val6;
			}));
			AddType(new DelegateConverter<IList>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0020: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				if (type.IsArray)
				{
					Type elementType = type.GetElementType();
					BaseConverter converter4 = GetConverter(elementType);
					int num = default(int);
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
					Array array2 = Array.CreateInstance(elementType, num);
					for (int k = 0; k < num; k++)
					{
						object value = converter4._Read(reader, elementType);
						array2.SetValue(value, k);
					}
					return array2;
				}
				Type[] genericArguments4 = type.GetGenericArguments();
				if (genericArguments4.Length < 1)
				{
					throw new Exception("Unsupported list given. Missing generics.");
				}
				BaseConverter converter5 = GetConverter(genericArguments4[0]);
				IList list2 = (IList)Activator.CreateInstance(type);
				int num2 = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				for (int l = 0; l < num2; l++)
				{
					object value2 = converter5._Read(reader, genericArguments4[0]);
					list2.Add(value2);
				}
				return list2;
			}, delegate(FastBufferWriter writer, IList val)
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				Type type7 = val.GetType();
				Type type8 = null;
				if (type7.IsArray)
				{
					type8 = type7.GetElementType();
				}
				else
				{
					Type[] genericArguments3 = type7.GetGenericArguments();
					if (genericArguments3.Length < 1)
					{
						throw new Exception("Unsupported list given. Missing generics.");
					}
					type8 = genericArguments3[0];
				}
				BaseConverter converter3 = GetConverter(type8);
				int count = val.Count;
				((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref count, default(ForPrimitives));
				foreach (object item in val)
				{
					converter3._Write(writer, item);
				}
			}, delegate(JToken token, Type type)
			{
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				JArray val5 = (JArray)(object)((token is JArray) ? token : null);
				if (val5 == null)
				{
					JTokenType type5 = token.Type;
					throw new Exception("JSON format invalid. Expected array, got " + ((object)(JTokenType)(ref type5)).ToString());
				}
				Type type6 = null;
				if (type.IsArray)
				{
					type6 = type.GetElementType();
				}
				else
				{
					Type[] genericArguments2 = type.GetGenericArguments();
					if (genericArguments2.Length < 1)
					{
						throw new Exception("Unsupported list given. Missing generics.");
					}
					type6 = genericArguments2[0];
				}
				BaseConverter converter2 = GetConverter(type6);
				if (type.IsArray)
				{
					Array array = Array.CreateInstance(type6, ((JContainer)val5).Count);
					for (int i = 0; i < ((JContainer)val5).Count; i++)
					{
						array.SetValue(converter2._FromJSON(val5[i], type6), i);
					}
					return array;
				}
				IList list = null;
				list = (IList)Activator.CreateInstance(type);
				for (int j = 0; j < ((JContainer)val5).Count; j++)
				{
					list.Add(converter2._FromJSON(val5[j], type6));
				}
				return list;
			}, delegate(IList val)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Expected O, but got Unknown
				Type type3 = val.GetType();
				Type type4 = null;
				if (type3.IsArray)
				{
					type4 = type3.GetElementType();
				}
				else
				{
					Type[] genericArguments = type3.GetGenericArguments();
					if (genericArguments.Length < 1)
					{
						throw new Exception("Unsupported list given. Missing generics.");
					}
					type4 = genericArguments[0];
				}
				BaseConverter converter = GetConverter(type4);
				JArray val4 = new JArray();
				foreach (object item2 in val)
				{
					val4.Add(converter._ToJSON(item2));
				}
				return (JToken)(object)val4;
			}));
			AddType(new DelegateConverter<Configuration>(delegate(FastBufferReader reader, Type type)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				Configuration configuration2 = (Configuration)Activator.CreateInstance(type);
				List<Configuration.ConfigField> fields4 = Configuration.GetFields(configuration2);
				foreach (Configuration.ConfigField item3 in fields4)
				{
					if (item3.Field.Converter != null)
					{
						item3.Value = item3.Field.Converter._Read(reader, item3.Field.Field.FieldType);
					}
				}
				return configuration2;
			}, delegate(FastBufferWriter writer, Configuration val)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				List<Configuration.ConfigField> fields3 = Configuration.GetFields(val);
				foreach (Configuration.ConfigField item4 in fields3)
				{
					if (item4.Field.Converter != null)
					{
						item4.Field.Converter._Write(writer, item4.Value);
					}
				}
			}, delegate(JToken token, Type type)
			{
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				JObject val3 = (JObject)(object)((token is JObject) ? token : null);
				if (val3 == null)
				{
					JTokenType type2 = token.Type;
					throw new Exception("JSON format invalid. Expected object, got " + ((object)(JTokenType)(ref type2)).ToString());
				}
				Configuration configuration = (Configuration)Activator.CreateInstance(type);
				List<Configuration.ConfigField> fields2 = Configuration.GetFields(configuration);
				foreach (Configuration.ConfigField item5 in fields2)
				{
					if (val3.ContainsKey(item5.Field.JSONName) && item5.Field.Converter != null)
					{
						item5.Value = item5.Field.Converter._FromJSON(val3[item5.Field.JSONName], item5.Field.Field.FieldType);
						if (!(item5.Value is Configuration))
						{
							item5.DefaultValue = item5.CloneValue();
						}
					}
				}
				configuration.LoadedFromJSON();
				return configuration;
			}, delegate(Configuration val)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				List<Configuration.ConfigField> fields = Configuration.GetFields(val);
				JObject val2 = new JObject();
				foreach (Configuration.ConfigField item6 in fields)
				{
					val2[item6.Field.JSONName] = item6.Field.Converter._ToJSON(item6.Value);
				}
				return (JToken)(object)val2;
			}));
		}

		public static BaseConverter GetConverter(Type t)
		{
			while (t != null)
			{
				if (Converters.ContainsKey(t))
				{
					return Converters[t];
				}
				Type[] interfaces = t.GetInterfaces();
				Type[] array = interfaces;
				foreach (Type key in array)
				{
					if (Converters.ContainsKey(key))
					{
						return Converters[key];
					}
				}
				t = t.BaseType;
			}
			return null;
		}

		public static void AddType<T>(Converter<T> converter)
		{
			Converters.Add(typeof(T), converter);
		}

		internal abstract void _Write(FastBufferWriter writer, object val);

		internal abstract object _Read(FastBufferReader reader, Type t);

		internal abstract JToken _ToJSON(object obj);

		internal abstract object _FromJSON(JToken token, Type t);
	}
	public abstract class Converter<T> : BaseConverter
	{
		public abstract T Read(FastBufferReader reader);

		public abstract void Write(FastBufferWriter writer, T val);

		public abstract JToken ToJSON(T obj);

		public abstract T FromJSON(JToken token);

		internal override object _Read(FastBufferReader reader, Type t)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Read(reader);
		}

		internal override void _Write(FastBufferWriter writer, object val)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Write(writer, (T)val);
		}

		internal override JToken _ToJSON(object obj)
		{
			return ToJSON((T)obj);
		}

		internal override object _FromJSON(JToken token, Type t)
		{
			return FromJSON(token);
		}
	}
	public class DelegateConverter<T> : Converter<T>
	{
		public delegate T FromJSONDelegate(JToken token, Type t);

		public delegate JToken ToJSONDelegate(T obj);

		public delegate T ReadDelegate(FastBufferReader reader, Type t);

		public delegate void WriteDelegate(FastBufferWriter writer, T val);

		internal FromJSONDelegate OnFromJSON;

		internal ToJSONDelegate OnToJSON;

		internal ReadDelegate OnRead;

		internal WriteDelegate OnWrite;

		public DelegateConverter(ReadDelegate read, WriteDelegate write, FromJSONDelegate fromJSON, ToJSONDelegate toJSON)
		{
			OnRead = read;
			OnWrite = write;
			OnFromJSON = fromJSON;
			OnToJSON = toJSON;
		}

		internal override object _FromJSON(JToken token, Type t)
		{
			return OnFromJSON(token, t);
		}

		internal override object _Read(FastBufferReader reader, Type t)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return OnRead(reader, t);
		}

		public override JToken ToJSON(T obj)
		{
			return OnToJSON(obj);
		}

		public override void Write(FastBufferWriter writer, T val)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			OnWrite(writer, val);
		}

		public override T Read(FastBufferReader reader)
		{
			throw new NotImplementedException();
		}

		public override T FromJSON(JToken token)
		{
			throw new NotImplementedException();
		}
	}
	public class LobbyConfiguration : Configuration
	{
		public class LobbyConfig : Configuration
		{
			[Slider(4f, 32f, ShowValue = true, InputWidth = 35f)]
			public int LobbySize = 8;

			public bool KeepOpen = true;

			public bool KeepOpenOnMoon = false;
		}

		public class GeneralConfig : Configuration
		{
			[Slider(0.1f, 10f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float GlobalScrapAmountMultiplier = 1f;

			[Slider(0.1f, 10f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float GlobalScrapValueMultiplier = 1f;

			[Slider(0.1f, 10f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float GlobalMaxPowerMultiplier = 1f;

			public int DeadlineLength = 3;

			public int StartCredits = 60;

			public bool ActivatePortableTerminal = true;

			public bool EnableCosmetics = true;

			public bool EnableExtendDeadline = true;

			public bool SaveSuitsAfterDeath = true;

			public bool SaveProgress = true;

			public bool IndividualXP = true;

			public bool DeactivateHotbar = false;

			public bool ResetXP = true;

			[Slider(0.1f, 10f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float XPMultiplier = 1f;

			public int StartingXP = 500;

			public int StartingShipXP = 0;

			[Slider(100f, 3500f, ShowValue = true, InputWidth = 35f)]
			public int DayLength = 700;
		}

		public class EnemyConfig : Configuration
		{
			public bool Active = true;

			public bool OverridePowerLevel;

			public int PowerLevel;
		}

		public class MoonConfig : Configuration
		{
			public class LootTableItem : Configuration
			{
				public bool Override;

				public int Rarity;
			}

			public class EnemyTableItem : Configuration
			{
				public bool Override;

				public int Rarity;
			}

			public bool OverridePrice;

			public int Price;

			public bool OverrideDungeonSize;

			public float DungeonSize;

			public bool OverrideMinScrapAmount;

			public int MinScrapAmount;

			public bool OverrideMaxScrapAmount;

			public int MaxScrapAmount;

			public bool OverrideScrapAmountModifier;

			public float ScrapAmountModifier = 1f;

			public bool OverrideScrapValueModifier;

			public float ScrapValueModifier = 1f;

			public Dictionary<string, LootTableItem> LootTable = new Dictionary<string, LootTableItem>();

			public bool OverrideDaytimeEnemiesMaxPower;

			public int DaytimeEnemiesMaxPower;

			public bool OverrideDaytimeEnemiesProbability;

			public float DaytimeEnemiesProbability;

			public Dictionary<string, EnemyTableItem> DaytimeEnemies = new Dictionary<string, EnemyTableItem>();

			public bool OverrideOutsideEnemiesMaxPower;

			public int OutsideEnemiesMaxPower;

			public Dictionary<string, EnemyTableItem> OutsideEnemies = new Dictionary<string, EnemyTableItem>();

			public bool OverrideInsideEnemiesMaxPower;

			public int InsideEnemiesMaxPower;

			public bool OverrideInsideEnemiesProbability;

			public float InsideEnemiesProbability;

			public Dictionary<string, EnemyTableItem> InsideEnemies = new Dictionary<string, EnemyTableItem>();
		}

		public class FreeMoonConfig : MoonConfig
		{
			public string Name;
		}

		public class WeatherConfig : Configuration
		{
			public bool OverrideScrapAmountMultiplier;

			public float ScrapAmountMultiplier;

			public bool OverrideScrapValueMultiplier;

			public float ScrapValueMultiplier;

			protected override void SetDefaults()
			{
				base.SetDefaults();
				SetDefault("OverrideScrapAmountMultiplier", false);
				SetDefault("ScrapAmountMultiplier", 1f);
				SetDefault("OverrideScrapValueMultiplier", false);
				SetDefault("ScrapValueMultiplier", 1f);
			}
		}

		public class MoonsConfig : Configuration
		{
			public Dictionary<string, MoonConfig> Moons = new Dictionary<string, MoonConfig>();

			public WeatherConfig ClearWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = false,
				ScrapAmountMultiplier = 1f,
				OverrideScrapValueMultiplier = false,
				ScrapValueMultiplier = 1f
			};

			public WeatherConfig FoggyWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = true,
				ScrapAmountMultiplier = 1.1f,
				OverrideScrapValueMultiplier = true,
				ScrapValueMultiplier = 1.1f
			};

			public WeatherConfig RainyWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = true,
				ScrapAmountMultiplier = 1.1f,
				OverrideScrapValueMultiplier = true,
				ScrapValueMultiplier = 1.1f
			};

			public WeatherConfig FloodedWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = true,
				ScrapAmountMultiplier = 1.3f,
				OverrideScrapValueMultiplier = true,
				ScrapValueMultiplier = 1.2f
			};

			public WeatherConfig StormyWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = true,
				ScrapAmountMultiplier = 1.5f,
				OverrideScrapValueMultiplier = true,
				ScrapValueMultiplier = 1.5f
			};

			public WeatherConfig EclipsedWeather = new WeatherConfig
			{
				OverrideScrapAmountMultiplier = true,
				ScrapAmountMultiplier = 1.8f,
				OverrideScrapValueMultiplier = true,
				ScrapValueMultiplier = 1.5f
			};

			public MoonsConfig()
			{
				LoadedFromJSON();
			}

			public override void LoadedFromJSON()
			{
				foreach (KeyValuePair<string, MoonConfig> moon in AllMoonsConfig.Moons)
				{
					if (!Moons.ContainsKey(moon.Key))
					{
						Moons[moon.Key] = (MoonConfig)moon.Value._Clone();
					}
					Moons[moon.Key].Field("OverrideDaytimeEnemiesMaxPower").DefaultValue = false;
					Moons[moon.Key].Field("OverrideDaytimeEnemiesProbability").DefaultValue = false;
					Moons[moon.Key].Field("OverrideDungeonSize").DefaultValue = false;
					Moons[moon.Key].Field("OverrideInsideEnemiesMaxPower").DefaultValue = false;
					Moons[moon.Key].Field("OverrideInsideEnemiesProbability").DefaultValue = false;
					Moons[moon.Key].Field("OverrideMaxScrapAmount").DefaultValue = false;
					Moons[moon.Key].Field("OverrideMinScrapAmount").DefaultValue = false;
					Moons[moon.Key].Field("OverrideOutsideEnemiesMaxPower").DefaultValue = false;
					Moons[moon.Key].Field("OverridePrice").DefaultValue = false;
					Moons[moon.Key].Field("OverrideScrapAmountModifier").DefaultValue = false;
					Moons[moon.Key].Field("OverrideScrapValueModifier").DefaultValue = false;
					Moons[moon.Key].Field("DaytimeEnemiesMaxPower").DefaultValue = moon.Value.DaytimeEnemiesMaxPower;
					Moons[moon.Key].Field("DaytimeEnemiesProbability").DefaultValue = moon.Value.DaytimeEnemiesProbability;
					Moons[moon.Key].Field("DungeonSize").DefaultValue = moon.Value.DungeonSize;
					Moons[moon.Key].Field("InsideEnemiesMaxPower").DefaultValue = moon.Value.InsideEnemiesMaxPower;
					Moons[moon.Key].Field("InsideEnemiesProbability").DefaultValue = moon.Value.InsideEnemiesProbability;
					Moons[moon.Key].Field("MaxScrapAmount").DefaultValue = moon.Value.MaxScrapAmount;
					Moons[moon.Key].Field("MinScrapAmount").DefaultValue = moon.Value.MinScrapAmount;
					Moons[moon.Key].Field("OutsideEnemiesMaxPower").DefaultValue = moon.Value.OutsideEnemiesMaxPower;
					Moons[moon.Key].Field("Price").DefaultValue = moon.Value.Price;
					Moons[moon.Key].Field("ScrapAmountModifier").DefaultValue = moon.Value.ScrapAmountModifier;
					Moons[moon.Key].Field("ScrapValueModifier").DefaultValue = moon.Value.ScrapValueModifier;
					foreach (KeyValuePair<string, MoonConfig.EnemyTableItem> daytimeEnemy in moon.Value.DaytimeEnemies)
					{
						if (Moons[moon.Key].DaytimeEnemies.ContainsKey(daytimeEnemy.Key))
						{
							Moons[moon.Key].DaytimeEnemies[daytimeEnemy.Key].Field("Override").DefaultValue = false;
							Moons[moon.Key].DaytimeEnemies[daytimeEnemy.Key].Field("Rarity").DefaultValue = daytimeEnemy.Value.Rarity;
						}
						else
						{
							Moons[moon.Key].DaytimeEnemies[daytimeEnemy.Key] = (MoonConfig.EnemyTableItem)daytimeEnemy.Value._Clone();
						}
					}
					foreach (KeyValuePair<string, MoonConfig.EnemyTableItem> outsideEnemy in moon.Value.OutsideEnemies)
					{
						if (Moons[moon.Key].OutsideEnemies.ContainsKey(outsideEnemy.Key))
						{
							Moons[moon.Key].OutsideEnemies[outsideEnemy.Key].Field("Override").DefaultValue = false;
							Moons[moon.Key].OutsideEnemies[outsideEnemy.Key].Field("Rarity").DefaultValue = outsideEnemy.Value.Rarity;
						}
						else
						{
							Moons[moon.Key].OutsideEnemies[outsideEnemy.Key] = (MoonConfig.EnemyTableItem)outsideEnemy.Value._Clone();
						}
					}
					foreach (KeyValuePair<string, MoonConfig.EnemyTableItem> insideEnemy in moon.Value.InsideEnemies)
					{
						if (Moons[moon.Key].InsideEnemies.ContainsKey(insideEnemy.Key))
						{
							Moons[moon.Key].InsideEnemies[insideEnemy.Key].Field("Override").DefaultValue = false;
							Moons[moon.Key].InsideEnemies[insideEnemy.Key].Field("Rarity").DefaultValue = insideEnemy.Value.Rarity;
						}
						else
						{
							Moons[moon.Key].InsideEnemies[insideEnemy.Key] = (MoonConfig.EnemyTableItem)insideEnemy.Value._Clone();
						}
					}
					foreach (KeyValuePair<string, MoonConfig.LootTableItem> item in moon.Value.LootTable)
					{
						if (Moons[moon.Key].LootTable.ContainsKey(item.Key))
						{
							Moons[moon.Key].LootTable[item.Key].Field("Override").DefaultValue = false;
							Moons[moon.Key].LootTable[item.Key].Field("Rarity").DefaultValue = item.Value.Rarity;
						}
						else
						{
							Moons[moon.Key].LootTable[item.Key] = (MoonConfig.LootTableItem)item.Value._Clone();
						}
					}
					foreach (KeyValuePair<string, ScrapConfig> item2 in AllScrapConfig.Items)
					{
						if (!Moons[moon.Key].LootTable.ContainsKey(item2.Key))
						{
							Moons[moon.Key].LootTable[item2.Key] = new MoonConfig.LootTableItem
							{
								Override = false,
								Rarity = 0
							};
						}
					}
					foreach (KeyValuePair<string, EnemyConfig> enemy in AllEnemiesConfig.Enemies)
					{
						if (!Moons[moon.Key].DaytimeEnemies.ContainsKey(enemy.Key))
						{
							Moons[moon.Key].DaytimeEnemies[enemy.Key] = new MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = 0
							};
						}
						if (!Moons[moon.Key].OutsideEnemies.ContainsKey(enemy.Key))
						{
							Moons[moon.Key].OutsideEnemies[enemy.Key] = new MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = 0
							};
						}
						if (!Moons[moon.Key].InsideEnemies.ContainsKey(enemy.Key))
						{
							Moons[moon.Key].InsideEnemies[enemy.Key] = new MoonConfig.EnemyTableItem
							{
								Override = false,
								Rarity = 0
							};
						}
					}
				}
			}
		}

		public class ScrapConfig : Configuration
		{
			public bool Active;

			public bool OverrideMinValue;

			public int MinValue;

			public bool OverrideMaxValue;

			public int MaxValue;

			public bool OverrideWeight;

			public float Weight;
		}

		public class ItemConfig : Configuration
		{
			public bool Active;

			public bool OverridePrice;

			public int Price;

			public bool OverrideMaxDiscount;

			public int MaxDiscount;

			public bool OverrideWeight;

			public float Weight;
		}

		public class UnlockableConfig : Configuration
		{
			public bool Active;

			public bool OverridePrice;

			public int Price;
		}

		public class NightVisionConfig : Configuration
		{
			public float BatteryTime = 180f;
		}

		public class BulletProofVestConfig : Configuration
		{
			public int MaxDamage = 90;

			public int TurretDamage = 5;

			public int ShotgunDamage = 30;

			[Slider(0f, 1f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float DamageReductionAtFullHealth = 1f;

			[Slider(0f, 1f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float DamageReductionAtNoHealth = 0.5f;

			public bool DestroyAtNoHealth = true;
		}

		public class HelmetLampConfig : Configuration
		{
			public float BatteryTime = 360f;
		}

		public class HeadsetConfig : Configuration
		{
			public float BatteryTime = 800f;
		}

		public class TacticalHelmetConfig : Configuration
		{
			public float BatteryTime = 900f;

			public float BatteryTimeWithLight = 500f;
		}

		public class FlippersConfig : Configuration
		{
			[Slider(0.5f, 3f, ShowValue = true, Conversion = 100f, InputWidth = 35f)]
			public float Speed = 1f;
		}

		public class CompabilityConfig : Configuration
		{
			public bool DisableEquipment;

			public bool DisablePortableTerminal;

			public bool DisablePlayerPerks;

			public int InventorySlots;

			public bool DisablePlayerTweaks;

			public bool DisableInventory;

			public bool DisableShipPerks;

			public bool DisableShipTweaks;

			public bool DisableMoonPrices;

			public bool DisableMoonModifiers;

			public bool DisableWeatherModifiers;

			public bool DisableItemWeight;

			public bool DisableItemPrice;

			public bool DisableItemDiscount;

			public bool DisableCosmetics;

			public bool DisableDayLength;

			public bool AnimationCompabilityMode;
		}

		public class ItemsConfig : Configuration
		{
			public Dictionary<string, ItemConfig> Items = new Dictionary<string, ItemConfig>();

			public Dictionary<string, ScrapConfig> Scrap = new Dictionary<string, ScrapConfig>();

			public Dictionary<string, UnlockableConfig> Unlockables = new Dictionary<string, UnlockableConfig>();

			public NightVisionConfig VisionEnhancer = new NightVisionConfig();

			public BulletProofVestConfig BulletProofVest = new BulletProofVestConfig();

			public HelmetLampConfig HelmetLamp = new HelmetLampConfig();

			public HeadsetConfig Headset = new HeadsetConfig();

			public TacticalHelmetConfig TacticalHelmet = new TacticalHelmetConfig();

			public FlippersConfig Flippers = new FlippersConfig();

			public ItemsConfig()
			{
				foreach (KeyValuePair<string, ItemConfig> item in AllItemsConfig.Items)
				{
					Items.Add(item.Key, (ItemConfig)item.Value._Clone());
				}
				foreach (KeyValuePair<string, ScrapConfig> item2 in AllScrapConfig.Items)
				{
					Scrap.Add(item2.Key, (ScrapConfig)item2.Value._Clone());
				}
				foreach (KeyValuePair<string, UnlockableConfig> unlockable in AllUnlockablesConfig.Unlockables)
				{
					Unlockables.Add(unlockable.Key, (UnlockableConfig)unlockable.Value._Clone());
				}
			}

			public override void LoadedFromJSON()
			{
				foreach (KeyValuePair<string, ItemConfig> item in AllItemsConfig.Items)
				{
					if (Items.ContainsKey(item.Key))
					{
						Items[item.Key].Field("OverridePrice").DefaultValue = false;
						Items[item.Key].Field("OverrideMaxDiscount").DefaultValue = false;
						Items[item.Key].Field("OverrideWeight").DefaultValue = false;
						Items[item.Key].Field("Price").DefaultValue = item.Value.Price;
						Items[item.Key].Field("MaxDiscount").DefaultValue = item.Value.MaxDiscount;
						Items[item.Key].Field("Weight").DefaultValue = item.Value.Weight;
					}
					else
					{
						Items[item.Key] = (ItemConfig)item.Value._Clone();
					}
				}
				foreach (KeyValuePair<string, ScrapConfig> item2 in AllScrapConfig.Items)
				{
					if (Scrap.ContainsKey(item2.Key))
					{
						Scrap[item2.Key].Field("OverrideMinValue").DefaultValue = false;
						Scrap[item2.Key].Field("OverrideMaxValue").DefaultValue = false;
						Scrap[item2.Key].Field("OverrideWeight").DefaultValue = false;
						Scrap[item2.Key].Field("MinValue").DefaultValue = item2.Value.MinValue;
						Scrap[item2.Key].Field("MaxValue").DefaultValue = item2.Value.MaxValue;
						Scrap[item2.Key].Field("Weight").DefaultValue = item2.Value.Weight;
					}
					else
					{
						Scrap[item2.Key] = (ScrapConfig)item2.Value._Clone();
					}
				}
				foreach (KeyValuePair<string, UnlockableConfig> unlockable in AllUnlockablesConfig.Unlockables)
				{
					if (Unlockables.ContainsKey(unlockable.Key))
					{
						Unlockables[unlockable.Key].Field("OverridePrice").DefaultValue = false;
						Unlockables[unlockable.Key].Field("Price").DefaultValue = unlockable.Value.Price;
					}
					else
					{
						Unlockables[unlockable.Key] = (UnlockableConfig)unlockable.Value._Clone();
					}
				}
			}

			public ItemConfig GetByItemName(string itemName)
			{
				if (itemName == null)
				{
					return null;
				}
				if (Items.ContainsKey(itemName))
				{
					return Items[itemName];
				}
				return null;
			}

			public UnlockableConfig GetByUnlockableName(string unlockableName)
			{
				if (unlockableName == null)
				{
					return null;
				}
				if (Unlockables.ContainsKey(unlockableName))
				{
					return Unlockables[unlockableName];
				}
				return null;
			}

			public ScrapConfig GetByScrapName(string itemName)
			{
				if (itemName == null)
				{
					return null;
				}
				if (Scrap.ContainsKey(itemName))
				{
					return Scrap[itemName];
				}
				return null;
			}
		}

		public class PerkConfiguration : Configuration
		{
			public bool Active;

			public float Base;

			public float Change;

			public int[] Prices;
		}

		public class ShipPerksConfig : Configuration
		{
			public PerkConfiguration ScanDistance = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[10] { 50, 100, 150, 200, 300, 400, 500, 600, 700, 800 }
			};

			public PerkConfiguration ExtraBattery = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.075f,
				Prices = new int[8] { 100, 150, 200, 250, 300, 350, 400, 500 }
			};

			public PerkConfiguration ExtendDeadlineDiscount = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[8] { 200, 300, 400, 500, 750, 1000, 1500, 2000 }
			};

			public PerkConfiguration LandingSpeed = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[10] { 50, 100, 200, 300, 400, 500, 600, 700, 800, 1000 }
			};

			public PerkConfiguration DeliverySpeed = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[10] { 50, 100, 200, 300, 400, 500, 600, 700, 800, 1000 }
			};

			public PerkConfiguration SaveLoot = new PerkConfiguration
			{
				Active = true,
				Base = 0f,
				Change = 0.1f,
				Prices = new int[8] { 200, 300, 400, 500, 750, 1000, 1500, 2000 }
			};

			public PerkConfiguration TravelDiscount = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.075f,
				Prices = new int[8] { 200, 400, 600, 800, 1000, 1250, 1500, 2000 }
			};
		}

		public class PlayerPerksConfig : Configuration
		{
			public PerkConfiguration SprintSpeed = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[5] { 150, 200, 250, 400, 500 }
			};

			public PerkConfiguration JumpHeight = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.05f,
				Prices = new int[5] { 100, 100, 150, 200, 250 }
			};

			public PerkConfiguration JumpStamina = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[6] { 100, 100, 150, 200, 250, 300 }
			};

			public PerkConfiguration SprintStamina = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[6] { 150, 300, 500, 750, 1000, 1500 }
			};

			public PerkConfiguration StaminaRegen = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[6] { 200, 400, 600, 800, 1200, 1500 }
			};

			public PerkConfiguration FallDamage = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.15f,
				Prices = new int[5] { 100, 200, 300, 400, 500 }
			};

			public PerkConfiguration Damage = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[7] { 150, 300, 500, 750, 1000, 1250, 1500 }
			};

			public PerkConfiguration Weight = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[5] { 150, 300, 500, 750, 1000 }
			};

			public PerkConfiguration WeightSpeed = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[5] { 200, 400, 600, 800, 1000 }
			};

			public PerkConfiguration DealDamage = new PerkConfiguration
			{
				Active = true,
				Base = 0f,
				Change = 0.1f,
				Prices = new int[8] { 150, 200, 250, 350, 500, 750, 1000, 1250 }
			};

			public PerkConfiguration ClimbingSpeed = new PerkConfiguration
			{
				Active = true,
				Base = 1f,
				Change = 0.1f,
				Prices = new int[8] { 50, 100, 150, 200, 250, 300, 350, 400 }
			};

			public PerkConfiguration InventorySlots = new PerkConfiguration
			{
				Active = true,
				Base = 3f,
				Change = 1f,
				Prices = new int[7] { 500, 1000, 1500, 2500, 3500, 5000, 7500 }
			};
		}

		public class EnemiesConfig : Configuration
		{
			public Dictionary<string, EnemyConfig> Enemies = new Dictionary<string, EnemyConfig>();

			public EnemiesConfig()
			{
				foreach (KeyValuePair<string, EnemyConfig> enemy in AllEnemiesConfig.Enemies)
				{
					Enemies.Add(enemy.Key, (EnemyConfig)enemy.Value._Clone());
				}
			}

			public EnemyConfig GetByEnemyName(string enemyName)
			{
				if (Enemies.ContainsKey(enemyName))
				{
					return Enemies[enemyName];
				}
				return null;
			}
		}

		internal static AllMoons AllMoonsConfig = new AllMoons();

		internal static AllItems AllItemsConfig = new AllItems();

		internal static AllUnlockables AllUnlockablesConfig = new AllUnlockables();

		internal static AllEnemies AllEnemiesConfig = new AllEnemies();

		internal static AllScrap AllScrapConfig = new AllScrap();

		public LobbyConfig Lobby = new LobbyConfig();

		public GeneralConfig General = new GeneralConfig();

		public MoonsConfig Moons = new MoonsConfig();

		public ItemsConfig Items = new ItemsConfig();

		public PlayerPerksConfig PlayerPerks = new PlayerPerksConfig();

		public ShipPerksConfig ShipPerks = new ShipPerksConfig();

		public EnemiesConfig Enemies = new EnemiesConfig();
	}
	public class PlayerConfiguration : Configuration
	{
		public class GraphicsConfig : Configuration
		{
			[Slider(0f, 1f, Conversion = 100f, ShowValue = true)]
			public float VisionEnhancerBrightness = 0.7f;

			[Slider(0f, 1f, Conversion = 100f, ShowValue = true)]
			public float MusicVolume = 1f;
		}

		public class FileConfig : Configuration
		{
			public bool SaveInProfile = false;
		}

		public class CompabilityConfig : Configuration
		{
			public bool DisableMusic;

			public bool HideEquipment;

			public bool HideCosmetics;

			public bool AnimationsCompability;
		}

		public class HotbarConfig : Configuration
		{
			[Slider(0.1f, 2f, Conversion = 100f, ShowValue = true)]
			public float HotbarScale = 1f;

			[Slider(0f, 1f, Conversion = 100f, ShowValue = true)]
			public float HotbarAlpha = 0.13f;

			[Slider(5f, 20f, Conversion = 1f, ShowValue = false)]
			public float HotbarSpacing = 10f;

			[Slider(10f, 50f, Conversion = 1f, ShowValue = false)]
			public float HotbarBorderWidth = 4f;

			[Slider(0f, 100f, Conversion = 1f, ShowValue = false)]
			public float HotbarY = 50f;

			public bool InvertScroll = true;
		}

		public class CosmeticsConfig : Configuration
		{
			public List<string> ActivatedCosmetics = new List<string>();
		}

		public FileConfig File = new FileConfig();

		public HotbarConfig Hotbar = new HotbarConfig();

		public CosmeticsConfig Cosmetics = new CosmeticsConfig();

		public CompabilityConfig Compability = new CompabilityConfig();

		public GraphicsConfig Graphics = new GraphicsConfig();
	}
}
namespace AdvancedCompany.Boot
{
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public class Bootable : Attribute
	{
	}
	public static class BootManager
	{
		public delegate void TypeCallback(Type t);

		private static List<TypeCallback> TypeCallbacks = new List<TypeCallback>();

		public static void AddTypeCallback(TypeCallback callback)
		{
			TypeCallbacks.Add(callback);
		}

		public static void Boot()
		{
			List<Type> list = new List<Type>();
			Dictionary<Type, int> dictionary = new Dictionary<Type, int>();
			Dictionary<Type, List<Type>> dictionary2 = new Dictionary<Type, List<Type>>();
			Type[] types = typeof(BootManager).Assembly.GetTypes();
			foreach (Type type in types)
			{
				Bootable customAttribute = type.GetCustomAttribute<Bootable>();
				if (customAttribute == null)
				{
					continue;
				}
				list.Add(type);
				List<Requires> list2 = type.GetCustomAttributes<Requires>().ToList();
				if (list2.Count() == 0)
				{
					dictionary.Add(type, 0);
					continue;
				}
				dictionary2.Add(type, new List<Type>());
				foreach (Requires item in list2)
				{
					dictionary2[type].Add(item.Type);
				}
			}
			int num = 1;
			while (dictionary2.Count > 0)
			{
				bool flag = false;
				List<Type> list3 = new List<Type>();
				Dictionary<Type, int> dictionary3 = new Dictionary<Type, int>();
				foreach (KeyValuePair<Type, List<Type>> item2 in dictionary2)
				{
					bool flag2 = true;
					foreach (Type item3 in item2.Value)
					{
						if (!dictionary.ContainsKey(item3))
						{
							flag2 = false;
							break;
						}
					}
					if (flag2)
					{
						flag = true;
						list3.Add(item2.Key);
						dictionary3.Add(item2.Key, num);
					}
				}
				foreach (Type item4 in list3)
				{
					dictionary2.Remove(item4);
				}
				foreach (KeyValuePair<Type, int> item5 in dictionary3)
				{
					dictionary.Add(item5.Key, item5.Value);
				}
				if (flag)
				{
					num++;
					continue;
				}
				throw new Exception("There seems to be a circular boot requirement.");
			}
			List<List<Type>> list4 = new List<List<Type>>();
			for (int j = 0; j < num; j++)
			{
				List<Type> list5 = new List<Type>();
				foreach (KeyValuePair<Type, int> item6 in dictionary)
				{
					if (item6.Value == j)
					{
						list5.Add(item6.Key);
					}
				}
				list4.Add(list5);
			}
			foreach (List<Type> item7 in list4)
			{
				foreach (Type item8 in item7)
				{
					MethodInfo method = item8.GetMethod("Boot", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
					if (method != null && method.GetParameters().Length == 0)
					{
						method.Invoke(null, new object[0]);
					}
				}
			}
			for (int k = 0; k < types.Length; k++)
			{
				for (int l = 0; l < TypeCallbacks.Count; l++)
				{
					TypeCallbacks[l](types[k]);
				}
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	public class Requires : Attribute
	{
		public Type Type;

		public Requires(Type type)
		{
			Type = type;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}