using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Rinor")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.4.0")]
[assembly: AssemblyInformationalVersion("0.5.4")]
[assembly: AssemblyProduct("Nornforged.Core")]
[assembly: AssemblyTitle("Nornforged.Core")]
[assembly: AssemblyVersion("0.5.4.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Nornforged.Core
{
	public static class ArsenalRegistry
	{
		public static readonly string[] Ids = new string[23]
		{
			"flanking_edge", "dueling_edge", "surrounded_edge", "relentless_edge", "grounded_impact", "martial_rhythm", "highground", "giant_hunter", "airborne_hunter", "steady_release",
			"pinning_shot", "shield_breath", "shield_mending", "shield_rebuke", "shield_composure", "parry_riposte", "wet_conduit", "cinder_hunter", "frozen_focus", "arcane_precision",
			"spell_repair", "sorcerers_breath", "soul_shelter"
		};

		public static void Add(List<PerkDefinition> target)
		{
			M("flanking_edge", "Flanking Edge", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct melee damage while behind the enemy, within the rear 120-degree arc.");
			M("dueling_edge", "Dueling Edge", PerkClass.Standard, 3.0, 220.0, "+{amount}% direct melee damage when the target is the only living hostile enemy within 6 m of you.");
			M("surrounded_edge", "Surrounded Edge", PerkClass.Special, 5.0, 420.0, "+{amount}% direct melee damage while at least 3 living hostile enemies are within 8 m of you.");
			M("relentless_edge", "Relentless Edge", PerkClass.Special, 5.0, 360.0, "+{amount}% direct melee damage against the same enemy you last dealt acknowledged direct damage to, within 3 s. This bonus does not stack with itself.");
			M("grounded_impact", "Grounded Impact", PerkClass.Standard, 5.0, 300.0, "+{amount}% native melee knockback against a grounded enemy; targets retain their native mass, resistance and knockback rules.", "attack,combat_damage,knockback");
			M("martial_rhythm", "Martial Rhythm", PerkClass.Ultra, 5.0, 85.0, "Every third paid manual melee attack that deals acknowledged direct enemy damage refunds {amount}% of that attack's actual stamina cost, capped at 85%. One count and refund per attack, even when it hits several enemies.", "direct_damage,attack_stamina");
			R("highground", "High Ground", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct projectile damage when its launch point is at least 3 m above the impact point.");
			R("giant_hunter", "Giant Hunter", PerkClass.Standard, 3.0, 270.0, "+{amount}% direct projectile damage against an enemy whose maximum health is at least 3 times yours.");
			R("airborne_hunter", "Airborne Hunter", PerkClass.Special, 5.0, 450.0, "+{amount}% direct projectile damage against an airborne enemy that is neither grounded nor swimming.");
			R("steady_release", "Steady Release", PerkClass.Special, 5.0, 330.0, "+{amount}% direct projectile damage while above 50% stamina and after at least 8 s without taking health damage; checked at impact.");
			R("pinning_shot", "Pinning Shot", PerkClass.Standard, 5.0, 240.0, "+{amount}% native stagger buildup from projectile hits at least 15 m from the launch point; no extra health damage.", "stagger_damage,projectile");
			C(S("shield_breath", "Shield Breath", PerkClass.Special, 5.0, 85.0, "A successful enemy block refunds {amount}% of stamina actually spent blocking, capped at 85%; {cooldown} s cooldown. The refund occurs after native block success is decided."), 1.0, 20.0);
			C(S("shield_mending", "Shield Mending", PerkClass.Special, 1.0, 60.0, "A successful enemy block restores {amount}% of this shield's missing durability; {cooldown} s cooldown.", "block,durability"), 3.0, 45.0);
			C(S("shield_rebuke", "Shield Rebuke", PerkClass.Ultra, 10.0, 600.0, "A successful enemy melee block deals frost damage equal to {amount}% of the physical and elemental damage actually blocked; {cooldown} s cooldown. Native frost resistance applies; no secondary triggers."), 2.0, 30.0);
			C(S("shield_composure", "Shield Composure", PerkClass.Standard, 5.0, 85.0, "A successful enemy projectile block shortens your remaining stamina-regeneration delay by {amount}%, capped at 85%; {cooldown} s cooldown."), 1.0, 15.0);
			C(S("parry_riposte", "Parry Riposte", PerkClass.Ultra, 15.0, 750.0, "A successful timed enemy shield block grants +{amount}% direct melee damage for 4 s; {cooldown} s cooldown. The same shield must remain equipped.", "block,parry"), 3.0, 35.0);
			E("wet_conduit", "Wet Conduit", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct spell damage against an enemy with the native Wet status before impact.");
			E("cinder_hunter", "Cinder Hunter", PerkClass.Standard, 3.0, 240.0, "+{amount}% direct spell damage against an enemy already affected by native Burning before impact.");
			E("frozen_focus", "Frozen Focus", PerkClass.Special, 5.0, 360.0, "+{amount}% direct spell damage against an enemy already affected by the native Frost slow before impact.");
			E("arcane_precision", "Arcane Precision", PerkClass.Special, 5.0, 420.0, "+{amount}% direct spell damage while above 75% health and above 50% Eitr; checked at impact.", "direct_damage,eitr");
			C(E("spell_repair", "Spell Repair", PerkClass.Special, 1.0, 60.0, "Acknowledged direct enemy spell damage restores {amount}% of the attacking staff's missing durability; {cooldown} s cooldown.", "direct_damage,durability"), 3.0, 45.0);
			C(E("sorcerers_breath", "Sorcerer's Breath", PerkClass.Ultra, 5.0, 75.0, "A direct offensive-spell enemy kill restores {amount}% maximum stamina; {cooldown} s cooldown. Damage-over-time and secondary kills do not count."), 3.0, 40.0);
			C(E("soul_shelter", "Soul Shelter", PerkClass.Ultra, 5.0, 75.0, "A direct offensive-spell enemy kill grants a barrier worth {amount}% maximum health for 6 s; {cooldown} s cooldown. Barriers take the strongest remaining amount; damage-over-time and secondary kills do not count."), 5.0, 60.0);
			static void C(PerkDefinition p, double min, double max)
			{
				p.Parameters.Add(new PerkParameter
				{
					Id = "cooldown",
					Min = min,
					Max = max,
					Unit = "s",
					Precision = 3,
					HigherIsBetter = false
				});
			}
			PerkDefinition D(string id, string name, PerkClass cls, double min, double max, string trigger, string categories, string caps)
			{
				PerkDefinition perkDefinition = new PerkDefinition
				{
					Id = id,
					Name = name,
					Effect = id,
					Class = cls,
					Categories = categories.Split(',').ToList(),
					RequiredCapabilities = caps.Split(',').ToList(),
					Parameters = new List<PerkParameter>
					{
						new PerkParameter
						{
							Id = "amount",
							Min = min,
							Max = max,
							Precision = 3,
							Unit = "%"
						}
					},
					Trigger = trigger,
					Stacking = "Conditional damage bonuses add before one multiplier and keep separate actual-damage attribution. Item-only effects use the attacking weapon or the shield that actually blocked. Character-wide cooldowns survive equipment swaps.",
					SafetyLimits = "Enemy direct hits only; secondary and reflected hits cannot start bonuses or rewards. Resource refunds require confirmed damage or actual successful blocks. Native resistance, armor, blocking, ownership and resource maxima remain."
				};
				target.Add(perkDefinition);
				return perkDefinition;
			}
			PerkDefinition E(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage")
			{
				return D(id, name, cls, min, max, text, "offensive_staff", caps);
			}
			PerkDefinition M(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage")
			{
				return D(id, name, cls, min, max, text, "melee", caps);
			}
			PerkDefinition R(string id, string name, PerkClass cls, double min, double max, string text, string caps = "direct_damage,projectile")
			{
				return D(id, name, cls, min, max, text, "bow,crossbow", caps);
			}
			PerkDefinition S(string id, string name, PerkClass cls, double min, double max, string text, string caps = "block")
			{
				return D(id, name, cls, min, max, text, "shield", caps);
			}
		}
	}
	public sealed class AuthorityStorage
	{
		private sealed class KeyMaterial
		{
			public readonly string Xml;

			public readonly string PublicXml;

			public readonly string Fingerprint;

			public KeyMaterial(string xml, string publicXml, string fingerprint)
			{
				Xml = xml;
				PublicXml = publicXml;
				Fingerprint = fingerprint;
			}
		}

		public const string KeyFileName = "authority-private-key.xml";

		public const string IdentityFileName = "authority-identity.json";

		private const int MaximumFileBytes = 16777216;

		private const int MaximumStartupValidationEntries = 65536;

		[ThreadStatic]
		private static HashSet<string>? startupDirectories;

		private readonly string backupDirectory;

		private readonly object gate = new object();

		private Dictionary<string, bool>? startupValidation;

		public string DirectoryPath { get; }

		public string Fingerprint { get; }

		public string PrivateKeyXml { get; }

		public string StatusMessage { get; private set; }

		private AuthorityStorage(string directory, string backup, KeyMaterial key, string status)
		{
			DirectoryPath = directory;
			backupDirectory = backup;
			Fingerprint = key.Fingerprint;
			PrivateKeyXml = key.Xml;
			StatusMessage = status;
		}

		public static AuthorityStorage Open(string dataDirectory, string backupDirectory, string legacyDirectory)
		{
			HashSet<string> hashSet = startupDirectories;
			startupDirectories = new HashSet<string>((Path.DirectorySeparatorChar == '\\') ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
			try
			{
				return OpenCore(dataDirectory, backupDirectory, legacyDirectory);
			}
			finally
			{
				startupDirectories = hashSet;
			}
		}

		private static AuthorityStorage OpenCore(string dataDirectory, string backupDirectory, string legacyDirectory)
		{
			string text = Root(dataDirectory);
			string text2 = Root(backupDirectory);
			string text3 = Root(legacyDirectory);
			if (Overlaps(text, text2) || Overlaps(text, text3) || Overlaps(text2, text3))
			{
				throw new ArgumentException("Authority data, backup and legacy directories must be separate, non-nested directories.");
			}
			string text4 = ReadWitness(text);
			string text5 = ReadWitness(text2);
			if (text4 != null && text5 != null && text4 != text5)
			{
				throw Failure("The data and backup identity witnesses disagree. Preserve both directories and restore the original matching authority backup while the server is stopped.");
			}
			string text6 = text4 ?? text5;
			KeyMaterial keyMaterial = ReadKey(SafePath(text, "authority-private-key.xml"));
			KeyMaterial keyMaterial2 = ReadKey(SafePath(text2, "authority-private-key.xml"));
			List<KeyMaterial> list = SavedKeys(text2).ToList();
			if (keyMaterial2 != null)
			{
				list.Add(keyMaterial2);
			}
			if (list.Select((KeyMaterial k) => k.Fingerprint).Distinct<string>(StringComparer.Ordinal).Count() > 1)
			{
				throw Failure("The backup contains different signing identities. No identity was selected automatically. Preserve all keys and restore a matching data/backup pair offline.");
			}
			keyMaterial2 = keyMaterial2 ?? list.FirstOrDefault();
			if (keyMaterial != null && text6 != null && keyMaterial.Fingerprint != text6)
			{
				throw Failure("The primary signing key does not match the saved server identity. No key was overwritten. Restore the matching original key offline.");
			}
			if (keyMaterial2 != null && text6 != null && keyMaterial2.Fingerprint != text6)
			{
				throw Failure("The backup signing key does not match the saved server identity. No key was overwritten. Restore a matching original backup offline.");
			}
			if (keyMaterial != null && keyMaterial2 != null && keyMaterial.Fingerprint != keyMaterial2.Fingerprint)
			{
				throw Failure("The primary and backup signing keys disagree. Preserve both keys and restore a matching authority backup offline.");
			}
			KeyMaterial keyMaterial3 = ReadKey(SafePath(text3, "authority-private-key.xml"));
			KeyMaterial keyMaterial4 = keyMaterial ?? keyMaterial2;
			bool flag = false;
			bool flag2 = keyMaterial == null && keyMaterial2 != null;
			bool flag3 = false;
			if (keyMaterial4 == null && keyMaterial3 != null)
			{
				if (text6 != null && keyMaterial3.Fingerprint != text6)
				{
					throw Failure("The legacy config key does not match the saved server identity. The original signing key is required; no replacement was generated.");
				}
				if (text6 == null && HasEvidence(text))
				{
					throw Failure("Authority data exists but its identity cannot be verified against the legacy config key. Restore the original key and matching backup offline.");
				}
				keyMaterial4 = keyMaterial3;
				flag = true;
			}
			if (keyMaterial4 == null)
			{
				if (HasEvidence(text) || HasEvidence(text2) || HasEvidence(text3))
				{
					throw Failure("An existing authority was detected but its signing key is missing or invalid. Existing item metadata is preserved. Restore the original authority backup; a new key cannot recover old signatures.");
				}
				using (RSACryptoServiceProvider rSACryptoServiceProvider = new RSACryptoServiceProvider(2048)
				{
					PersistKeyInCsp = false
				})
				{
					keyMaterial4 = ParseKey(rSACryptoServiceProvider.ToXmlString(includePrivateParameters: true));
				}
				flag3 = true;
			}
			if (text6 != null && keyMaterial4.Fingerprint != text6)
			{
				throw Failure("The signing key does not match the saved server identity. Restore the original key offline.");
			}
			string text7 = (flag3 ? "New authority identity created and backed up outside the config folder." : (flag ? "Existing authority key and records migrated outside the config folder; the legacy originals were preserved." : (flag2 ? "Original authority signing key restored automatically from its matching independent backup." : "Authority identity verified; independent backups are available.")));
			if (keyMaterial3 != null && keyMaterial3.Fingerprint != keyMaterial4.Fingerprint)
			{
				text7 += " The different legacy config key was ignored and preserved; this server continues using its established identity.";
			}
			AuthorityStorage authorityStorage = new AuthorityStorage(text, text2, keyMaterial4, text7);
			authorityStorage.startupValidation = new Dictionary<string, bool>(StringComparer.Ordinal);
			try
			{
				List<string> list2 = new List<string> { text2, text };
				if (keyMaterial3 != null && keyMaterial3.Fingerprint == keyMaterial4.Fingerprint)
				{
					list2.Insert(0, text3);
				}
				Dictionary<string, string> dictionary = authorityStorage.CollectRecords(list2);
				Directory.CreateDirectory(text);
				Directory.CreateDirectory(text2);
				WriteImmutable(SafePath(text2, Path.Combine("keys", keyMaterial4.Fingerprint + ".xml")), keyMaterial4.Xml);
				authorityStorage.SaveKeyAndWitness(text2, keyMaterial4);
				authorityStorage.SaveKeyAndWitness(text, keyMaterial4);
				foreach (KeyValuePair<string, string> item in dictionary)
				{
					authorityStorage.RestoreRecord(text, item.Key, item.Value);
					authorityStorage.BackupFile(item.Key);
				}
				return authorityStorage;
			}
			finally
			{
				authorityStorage.startupValidation = null;
			}
		}

		public void BackupFile(string relativePath)
		{
			lock (gate)
			{
				ValidateRecordPath(relativePath);
				string text = ReadText(SafePath(DirectoryPath, relativePath));
				if (!ValidRecord(relativePath, text))
				{
					throw Failure("An authority record is invalid; its original file was preserved and no backup was overwritten.");
				}
				string path = SafePath(backupDirectory, relativePath);
				if (File.Exists(path))
				{
					string text2 = ReadText(path);
					if (text2 == text)
					{
						return;
					}
					if (ValidRecord(relativePath, text2))
					{
						if (SelectRecord(relativePath, text2, text) != text)
						{
							throw Failure("A committed authority backup cannot be replaced by an older prepared transaction.");
						}
						Archive(relativePath, text2);
					}
					else
					{
						Quarantine(path, backupDirectory);
					}
				}
				Archive(relativePath, text);
				AtomicWrite(path, text);
			}
		}

		private Dictionary<string, string> CollectRecords(IEnumerable<string> roots)
		{
			Dictionary<string, string> result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string root in roots)
			{
				foreach (string item in RecordPaths(root))
				{
					string text = ReadText(SafePath(root, item));
					if (!ValidRecord(item, text))
					{
						hashSet.Add(item);
					}
					else
					{
						result[item] = (result.TryGetValue(item, out string value) ? SelectRecord(item, value, text) : text);
					}
				}
			}
			foreach (KeyValuePair<string, string> item2 in HistoryRecords())
			{
				if (!ValidRecord(item2.Key, item2.Value))
				{
					hashSet.Add(item2.Key);
				}
				else
				{
					result[item2.Key] = (result.TryGetValue(item2.Key, out string value2) ? SelectRecord(item2.Key, value2, item2.Value) : item2.Value);
				}
			}
			if (hashSet.Any((string path) => !result.ContainsKey(path)))
			{
				throw Failure("An authority receipt or configuration snapshot is invalid and has no valid matching backup. Originals were preserved; restore a matching authority backup offline.");
			}
			foreach (KeyValuePair<string, string> item3 in result.Where<KeyValuePair<string, string>>((KeyValuePair<string, string> pair) => !pair.Key.Replace('\\', '/').StartsWith("configurations/", StringComparison.Ordinal)))
			{
				string text2 = ((JToken)JObject.Parse(item3.Value)).Value<string>((object)"Config") ?? "";
				if (IsHash(text2) && !result.ContainsKey(Path.Combine("configurations", text2 + ".json")))
				{
					throw Failure("A saved craft refers to a missing configuration snapshot. Restore the complete original authority backup, including its configurations directory.");
				}
			}
			return result;
		}

		private IEnumerable<KeyValuePair<string, string>> HistoryRecords()
		{
			string path = SafePath(backupDirectory, "history");
			if (!Directory.Exists(path))
			{
				yield break;
			}
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				AssertNoLinks(path2);
				string group = Path.GetFileName(path2);
				if (group != "configurations" && !long.TryParse(group, out var _))
				{
					continue;
				}
				string[] directories2 = Directory.GetDirectories(path2);
				foreach (string path3 in directories2)
				{
					AssertNoLinks(path3);
					string relative = Path.Combine(group, Path.GetFileName(path3));
					ValidateRecordPath(relative);
					string[] files = Directory.GetFiles(path3);
					foreach (string text in files)
					{
						AssertNoLinks(text);
						if (text.EndsWith(".bak", StringComparison.Ordinal))
						{
							string text2 = ReadText(text);
							if (Hash(text2) != Path.GetFileNameWithoutExtension(text))
							{
								throw Failure("An immutable authority record archive failed its checksum. Preserve the backup and restore its matching original copy offline.");
							}
							yield return new KeyValuePair<string, string>(relative, text2);
						}
					}
				}
			}
		}

		private string SelectRecord(string relative, string first, string second)
		{
			if (first == second)
			{
				return first;
			}
			JObject val = JObject.Parse(first);
			JObject val2 = JObject.Parse(second);
			if (JToken.DeepEquals((JToken)(object)val, (JToken)(object)val2))
			{
				return second;
			}
			if (relative.Replace('\\', '/').StartsWith("configurations/", StringComparison.Ordinal))
			{
				throw Failure("Different configuration snapshots share the same identity; originals were preserved.");
			}
			bool valueOrDefault = ((JToken)val).Value<bool?>((object)"Committed") == true;
			bool valueOrDefault2 = ((JToken)val2).Value<bool?>((object)"Committed") == true;
			if (valueOrDefault != valueOrDefault2)
			{
				val.Remove("Committed");
				val2.Remove("Committed");
				val.Remove("Items");
				val2.Remove("Items");
				if (JToken.DeepEquals((JToken)(object)val, (JToken)(object)val2))
				{
					if (!valueOrDefault)
					{
						return second;
					}
					return first;
				}
			}
			throw Failure("Different authority records share a transaction ID. No record was overwritten; restore the matching original receipt offline.");
		}

		private bool ValidRecord(string relative, string text)
		{
			Dictionary<string, bool> dictionary = startupValidation;
			if (dictionary == null)
			{
				return ValidateRecordContents(relative, text);
			}
			string key = relative + "\n" + Hash(text);
			if (dictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			value = ValidateRecordContents(relative, text);
			if (dictionary.Count < 65536)
			{
				dictionary.Add(key, value);
			}
			return value;
		}

		private bool ValidateRecordContents(string relative, string text)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Invalid comparison between Unknown and I4
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Invalid comparison between Unknown and I4
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Invalid comparison between Unknown and I4
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Invalid comparison between Unknown and I4
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Invalid comparison between Unknown and I4
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Invalid comparison between Unknown and I4
			try
			{
				if (relative.Replace('\\', '/').StartsWith("configurations/", StringComparison.Ordinal))
				{
					return Hash(text) == Path.GetFileNameWithoutExtension(relative) && JObject.Parse(text) != null;
				}
				JObject val = JObject.Parse(text);
				JToken obj = val["Transaction"];
				if (obj == null || (int)obj.Type != 8)
				{
					return false;
				}
				if (((JToken)val).Value<string>((object)"Transaction") != Path.GetFileNameWithoutExtension(relative))
				{
					return false;
				}
				if (val["Config"] != null && (int)val["Config"].Type != 8)
				{
					return false;
				}
				JToken obj2 = val["Committed"];
				if (obj2 != null && (int)obj2.Type == 9)
				{
					JToken obj3 = val["Items"];
					JArray val2 = (JArray)(object)((obj3 is JArray) ? obj3 : null);
					if (val2 != null)
					{
						JToken val3 = val["OutputExclusion"];
						bool flag = val3 != null && (int)val3.Type != 10;
						if (((JToken)val).Value<bool>((object)"Committed"))
						{
							JToken obj4 = val["Prefab"];
							if (obj4 == null || (int)obj4.Type != 8)
							{
								return false;
							}
							if (((JContainer)val2).Count > 128 || (((JContainer)val2).Count != 0 && flag))
							{
								return false;
							}
							using RSACryptoServiceProvider rSACryptoServiceProvider = new RSACryptoServiceProvider
							{
								PersistKeyInCsp = false
							};
							rSACryptoServiceProvider.FromXmlString(PrivateKeyXml);
							if (((JContainer)val2).Count == 0)
							{
								if (!flag || !ValidSignedEnvelope(val3, ((JToken)val).Value<string>((object)"Prefab"), rSACryptoServiceProvider))
								{
									return false;
								}
								JObject val4 = JObject.Parse(val3.Value<string>((object)"Json"));
								JToken obj5 = val4["Kind"];
								if (obj5 == null || (int)obj5.Type != 8 || ((JToken)val4).Value<string>((object)"Kind") != "processor-exclusion-v1")
								{
									return false;
								}
								string[] array = new string[4] { "Transaction", "Prefab", "Host", "Recipe" };
								int num = 0;
								while (num < array.Length)
								{
									string text2 = array[num];
									JToken obj6 = val[text2];
									if (obj6 != null && (int)obj6.Type == 8)
									{
										JToken obj7 = val4[text2];
										if (obj7 != null && (int)obj7.Type == 8 && !(((JToken)val).Value<string>((object)text2) != ((JToken)val4).Value<string>((object)text2)))
										{
											num++;
											continue;
										}
									}
									return false;
								}
								if (!((JToken)val).Value<string>((object)"Host").StartsWith("processor:", StringComparison.Ordinal) || !((JToken)val).Value<string>((object)"Recipe").StartsWith("processor:piece_FrostFoundry:", StringComparison.Ordinal))
								{
									return false;
								}
							}
							foreach (JToken item in val2)
							{
								if (!ValidSignedEnvelope(item, ((JToken)val).Value<string>((object)"Prefab"), rSACryptoServiceProvider))
								{
									return false;
								}
							}
						}
						else if (((JContainer)val2).Count != 0 || flag)
						{
							return false;
						}
						return true;
					}
				}
				return false;
			}
			catch (Exception ex) when (ex is JsonException || ex is FormatException || ex is CryptographicException || ex is ArgumentException || ex is InvalidOperationException || ex is OverflowException)
			{
				return false;
			}
		}

		private bool ValidSignedEnvelope(JToken envelope, string prefab, RSACryptoServiceProvider rsa)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Invalid comparison between Unknown and I4
			if (envelope is JObject)
			{
				JToken obj = envelope[(object)"Issuer"];
				if (obj != null && (int)obj.Type == 8)
				{
					JToken obj2 = envelope[(object)"Json"];
					if (obj2 != null && (int)obj2.Type == 8)
					{
						JToken obj3 = envelope[(object)"Signature"];
						if (obj3 != null && (int)obj3.Type == 8)
						{
							if (envelope.Value<string>((object)"Issuer") != Fingerprint)
							{
								return false;
							}
							string s = prefab + "\n" + envelope.Value<string>((object)"Json");
							return rsa.VerifyData(Encoding.UTF8.GetBytes(s), "2.16.840.1.101.3.4.2.1", Convert.FromBase64String(envelope.Value<string>((object)"Signature") ?? ""));
						}
					}
				}
			}
			return false;
		}

		private void RestoreRecord(string root, string relative, string contents)
		{
			string path = SafePath(root, relative);
			if (File.Exists(path))
			{
				string text = ReadText(path);
				if (text == contents)
				{
					return;
				}
				if (!ValidRecord(relative, text))
				{
					Quarantine(path, root);
				}
				else
				{
					Archive(relative, text);
				}
			}
			AtomicWrite(path, contents);
		}

		private void Archive(string relative, string contents)
		{
			WriteImmutable(SafePath(backupDirectory, Path.Combine("history", relative, Hash(contents) + ".bak")), contents);
		}

		private void SaveKeyAndWitness(string root, KeyMaterial key)
		{
			string path = SafePath(root, "authority-private-key.xml");
			if (File.Exists(path))
			{
				KeyMaterial keyMaterial = ReadKey(path);
				if (keyMaterial == null)
				{
					Quarantine(path, root);
					AtomicWrite(path, key.Xml);
				}
				else if (keyMaterial.Fingerprint != key.Fingerprint)
				{
					throw Failure("Refusing to replace a different signing key.");
				}
			}
			if (!File.Exists(path))
			{
				AtomicWrite(path, key.Xml);
			}
			string path2 = SafePath(root, "authority-identity.json");
			string contents = JsonConvert.SerializeObject((object)new
			{
				Schema = 1,
				Fingerprint = key.Fingerprint,
				PublicKey = key.PublicXml
			}, (Formatting)1);
			if (File.Exists(path2) && ReadWitness(root) == null)
			{
				Quarantine(path2, root);
				AtomicWrite(path2, contents);
			}
			if (!File.Exists(path2))
			{
				AtomicWrite(path2, contents);
			}
		}

		private static IEnumerable<string> RecordPaths(string root)
		{
			if (!Directory.Exists(root))
			{
				yield break;
			}
			string[] directories = Directory.GetDirectories(root);
			foreach (string path in directories)
			{
				AssertNoLinks(path);
				string name = Path.GetFileName(path);
				if (name != "configurations" && !long.TryParse(name, out var _))
				{
					continue;
				}
				string[] files = Directory.GetFiles(path);
				foreach (string text in files)
				{
					AssertNoLinks(text);
					if (text.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
					{
						string text2 = Path.Combine(name, Path.GetFileName(text));
						ValidateRecordPath(text2);
						yield return text2;
					}
				}
			}
		}

		private static void ValidateRecordPath(string relative)
		{
			if (string.IsNullOrWhiteSpace(relative) || Path.IsPathRooted(relative))
			{
				throw new ArgumentException("A relative authority record path is required.");
			}
			string[] array = relative.Replace('\\', '/').Split('/');
			if (array.Length != 2 || array.Any(delegate(string p)
			{
				switch (p)
				{
				default:
					return p.IndexOf(':') >= 0;
				case "":
				case ".":
				case "..":
					return true;
				}
			}) || !array[1].EndsWith(".json", StringComparison.Ordinal))
			{
				throw new ArgumentException("Only world transaction JSON and configuration snapshots may be backed up.");
			}
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(array[1]);
			long result;
			Guid result2;
			if (array[0] == "configurations")
			{
				if (!IsHash(fileNameWithoutExtension))
				{
					throw new ArgumentException("Configuration snapshots require their SHA-256 filename.");
				}
			}
			else if (!long.TryParse(array[0], out result) || !Guid.TryParseExact(fileNameWithoutExtension, "N", out result2))
			{
				throw new ArgumentException("A valid world and transaction identifier is required.");
			}
		}

		private static IEnumerable<KeyMaterial> SavedKeys(string root)
		{
			string path = SafePath(root, "keys");
			if (!Directory.Exists(path))
			{
				yield break;
			}
			string[] files = Directory.GetFiles(path);
			foreach (string text in files)
			{
				AssertNoLinks(text);
				if (text.EndsWith(".xml", StringComparison.Ordinal))
				{
					KeyMaterial keyMaterial = ReadKey(text);
					if (keyMaterial == null || Path.GetFileNameWithoutExtension(text) != keyMaterial.Fingerprint)
					{
						throw Failure("An immutable authority key backup is invalid. Preserve it and restore the matching original backup offline.");
					}
					yield return keyMaterial;
				}
			}
		}

		private static string? ReadWitness(string root)
		{
			string path = SafePath(root, "authority-identity.json");
			if (!File.Exists(path))
			{
				return null;
			}
			try
			{
				JObject obj = JObject.Parse(ReadText(path));
				string text = ((JToken)obj).Value<string>((object)"Fingerprint");
				string text2 = ((JToken)obj).Value<string>((object)"PublicKey");
				if (((JToken)obj).Value<int?>((object)"Schema") != 1 || !IsHash(text) || string.IsNullOrWhiteSpace(text2))
				{
					return null;
				}
				using RSACryptoServiceProvider rSACryptoServiceProvider = new RSACryptoServiceProvider
				{
					PersistKeyInCsp = false
				};
				rSACryptoServiceProvider.FromXmlString(text2);
				return (Hash(rSACryptoServiceProvider.ToXmlString(includePrivateParameters: false)) == text) ? text : null;
			}
			catch (Exception ex) when (ex is JsonException || ex is CryptographicException || ex is ArgumentException || ex is FormatException || ex is XmlException || ex.GetType().FullName == "System.Security.XmlSyntaxException")
			{
				return null;
			}
		}

		private static KeyMaterial? ReadKey(string path)
		{
			if (!File.Exists(path))
			{
				return null;
			}
			return ParseKey(ReadText(path));
		}

		private static KeyMaterial? ParseKey(string xml)
		{
			try
			{
				using RSACryptoServiceProvider rSACryptoServiceProvider = new RSACryptoServiceProvider
				{
					PersistKeyInCsp = false
				};
				rSACryptoServiceProvider.FromXmlString(xml);
				if (rSACryptoServiceProvider.PublicOnly || rSACryptoServiceProvider.KeySize < 2048)
				{
					return null;
				}
				byte[] bytes = Encoding.UTF8.GetBytes("Nornforged authority key check");
				if (!rSACryptoServiceProvider.VerifyData(bytes, "2.16.840.1.101.3.4.2.1", rSACryptoServiceProvider.SignData(bytes, "2.16.840.1.101.3.4.2.1")))
				{
					return null;
				}
				string text = rSACryptoServiceProvider.ToXmlString(includePrivateParameters: false);
				return new KeyMaterial(xml, text, Hash(text));
			}
			catch (Exception ex) when (ex is CryptographicException || ex is ArgumentException || ex is FormatException || ex is XmlException || ex.GetType().FullName == "System.Security.XmlSyntaxException")
			{
				return null;
			}
		}

		private static bool HasEvidence(string root)
		{
			if (Directory.Exists(root))
			{
				return Directory.EnumerateFileSystemEntries(root).Any();
			}
			return false;
		}

		private static bool IsHash(string? value)
		{
			if (value != null && value.Length == 64)
			{
				return value.All((char c) => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'));
			}
			return false;
		}

		private static string Hash(string text)
		{
			using SHA256 sHA = SHA256.Create();
			return BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(text))).Replace("-", "").ToLowerInvariant();
		}

		private static InvalidOperationException Failure(string message)
		{
			return new InvalidOperationException("Nornforged authority recovery required: " + message);
		}

		private static string Root(string path)
		{
			if (string.IsNullOrWhiteSpace(path) || !Path.IsPathRooted(path))
			{
				throw new ArgumentException("Authority directories must use absolute paths.");
			}
			if (Path.DirectorySeparatorChar == '\\')
			{
				path = path.Replace('/', '\\');
			}
			string text = Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
			if (string.Equals(text, Path.GetPathRoot(text)?.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("A filesystem root cannot be an authority directory.");
			}
			if (Path.DirectorySeparatorChar == '\\' && !text.StartsWith("\\\\?\\", StringComparison.Ordinal))
			{
				text = (text.StartsWith("\\\\", StringComparison.Ordinal) ? ("\\\\?\\UNC\\" + text.Substring(2)) : ("\\\\?\\" + text));
			}
			AssertNoLinks(text);
			return text;
		}

		private static bool Overlaps(string first, string second)
		{
			if (!string.Equals(first, second, StringComparison.OrdinalIgnoreCase) && !first.StartsWith(second + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
			{
				return second.StartsWith(first + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static string SafePath(string root, string relative)
		{
			if (Path.IsPathRooted(relative) || relative.Replace('\\', '/').Split('/').Any((string s) => s == ".." || s == "." || s.IndexOf(':') >= 0))
			{
				throw new ArgumentException("Unsafe authority path.");
			}
			relative = relative.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar);
			string fullPath = Path.GetFullPath(Path.Combine(root, relative));
			if (!fullPath.StartsWith(root + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
			{
				throw new ArgumentException("Authority path escaped its directory.");
			}
			AssertNoLinks(fullPath);
			return fullPath;
		}

		private static void AssertNoLinks(string path)
		{
			HashSet<string> hashSet = startupDirectories;
			List<string> list = ((hashSet != null) ? new List<string>() : null);
			int num = 0;
			for (string text = path; !string.IsNullOrEmpty(text); text = ParentPath(text))
			{
				if (++num > 1024)
				{
					throw new IOException("Authority directory nesting exceeds the supported limit.");
				}
				if (hashSet != null && hashSet.Contains(text))
				{
					break;
				}
				FileAttributes attributes;
				try
				{
					attributes = File.GetAttributes(text);
				}
				catch (FileNotFoundException)
				{
					continue;
				}
				catch (DirectoryNotFoundException)
				{
					continue;
				}
				if ((attributes & FileAttributes.ReparsePoint) != FileAttributes.None)
				{
					throw new IOException("Authority data paths cannot contain symbolic links or junctions.");
				}
				if ((attributes & FileAttributes.Directory) != FileAttributes.None)
				{
					list?.Add(text);
				}
			}
			if (hashSet == null || list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				if (hashSet.Count >= 65536)
				{
					break;
				}
				hashSet.Add(item);
			}
		}

		private static string? ParentPath(string path)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (string.IsNullOrEmpty(directoryName) || string.Equals(path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), directoryName.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), (Path.DirectorySeparatorChar == '\\') ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
			{
				return null;
			}
			return directoryName;
		}

		private static string ReadText(string path)
		{
			AssertNoLinks(path);
			if (new FileInfo(path).Length > 16777216)
			{
				throw Failure("Authority file exceeds the supported size; its original content was preserved.");
			}
			return File.ReadAllText(path, Encoding.UTF8);
		}

		private static void Quarantine(string path, string root)
		{
			string text = ReadText(path);
			string path2 = SafePath(root, Path.Combine("quarantine", Path.GetFileName(path) + "." + Hash(text) + ".invalid"));
			WriteImmutable(path2, text);
			if (ReadText(path2) != text)
			{
				throw new IOException("Failed to preserve invalid authority data.");
			}
		}

		private static void WriteImmutable(string path, string contents)
		{
			if (File.Exists(path))
			{
				if (ReadText(path) != contents)
				{
					throw Failure("An immutable authority archive already exists with different contents; it was not overwritten.");
				}
			}
			else
			{
				AtomicWrite(path, contents, replaceExisting: false);
			}
		}

		private static void AtomicWrite(string path, string contents, bool replaceExisting = true)
		{
			AssertNoLinks(path);
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			string text = Path.Combine(Path.GetDirectoryName(path), ".nf-" + Guid.NewGuid().ToString("N") + ".tmp");
			using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough))
			{
				using StreamWriter streamWriter = new StreamWriter(fileStream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				streamWriter.Write(contents);
				streamWriter.Flush();
				fileStream.Flush(flushToDisk: true);
			}
			if (replaceExisting && File.Exists(path))
			{
				File.Replace(text, path, null);
			}
			else
			{
				File.Move(text, path);
			}
		}
	}
	public static class Balance020
	{
		public const string Version = "0.2.0";

		public const int GameplayPrecision = 3;

		public static void Apply(IReadOnlyList<PerkDefinition> definitions)
		{
			Dictionary<string, (double, double)> dictionary = Ranges();
			int num = 0;
			foreach (PerkDefinition definition in definitions)
			{
				foreach (PerkParameter parameter in definition.Parameters)
				{
					string text = definition.Id + "." + parameter.Id;
					if (!dictionary.TryGetValue(text, out var value))
					{
						throw new InvalidOperationException("Missing reviewed 0.2.0 balance range: " + text);
					}
					parameter.Min = value.Item1;
					parameter.Max = value.Item2;
					parameter.Precision = 3;
					num++;
				}
			}
			if (num != dictionary.Count)
			{
				throw new InvalidOperationException("The 0.2.0 balance table contains an unused parameter range.");
			}
		}

		public static Dictionary<string, (double Min, double Max)> Ranges()
		{
			Dictionary<string, (double, double)> result = new Dictionary<string, (double, double)>(StringComparer.Ordinal);
			A("razor_edge", 1.0, 50.0);
			A("runic_potency", 1.0, 48.0);
			A("efficient_strikes", 1.0, 38.0);
			A("quickstrike", 0.5, 25.0);
			A("quick_draw", 1.0, 35.0);
			A("rapid_reload", 1.0, 35.0);
			A("steady_aim", 1.0, 38.0);
			A("eitr_efficiency", 0.5, 35.0);
			A("punishing_blows", 1.0, 55.0);
			A("crushing_force", 1.0, 50.0);
			A("duelists_guard", 1.0, 50.0);
			A("reinforced", 3.0, 220.0);
			A("lightweight", 1.0, 75.0);
			A("frostbound", 0.5, 28.0);
			A("emberbound", 0.5, 28.0);
			A("resource_breaker", 1.0, 65.0);
			A("efficient_labor", 1.0, 38.0);
			A("swift_labor", 0.5, 30.0);
			A("resource_magnet", 2.0, 180.0);
			A("extended_reach", 1.0, 55.0);
			A("haulers_strength", 1.0, 35.0);
			A("builders_reach", 1.0, 70.0);
			A("green_hands", 1.0, 45.0);
			A("patient_angler", 1.0, 45.0);
			A("long_cast", 1.0, 55.0);
			A("fortified", 0.5, 30.0);
			A("vitality", 0.5, 22.0);
			A("endurance", 0.5, 25.0);
			A("runic_reservoir", 1.0, 30.0);
			A("recovery", 1.0, 50.0);
			A("second_wind", 1.0, 50.0);
			A("runic_flow", 1.0, 50.0);
			A("fleetfoot", 0.25, 12.0);
			A("tireless", 1.0, 32.0);
			A("nimble", 1.0, 32.0);
			A("springstep", 1.0, 32.0);
			A("riverstride", 1.0, 32.0);
			A("quiet_steps", 1.0, 32.0);
			string[] array = new string[8] { "fire", "frost", "lightning", "poison", "spirit", "blunt", "slash", "pierce" };
			foreach (string text in array)
			{
				A("ward_" + text, 0.5, (text == "fire" || text == "frost") ? 20 : 16);
			}
			A("soft_landing", 2.0, 75.0);
			A("efficient_guard", 1.0, 38.0);
			A("firm_grip", 1.0, 60.0);
			A("stormspark", 5.0, 100.0);
			C("stormspark", 3.0, 24.0);
			A("executioner", 3.0, 65.0);
			A("runic_reserve", 3.0, 65.0);
			A("veinbreaker", 10.0, 220.0);
			A("natures_favor", 1.0, 65.0);
			A("master_repair", 1.0, 9.0);
			C("master_repair", 1.0, 20.0);
			A("emergency_ward", 2.0, 35.0);
			C("emergency_ward", 20.0, 240.0);
			A("windstep", 1.0, 30.0);
			C("windstep", 3.0, 45.0);
			A("runic_guard", 2.0, 30.0);
			C("runic_guard", 5.0, 90.0);
			A("second_breath", 2.0, 35.0);
			C("second_breath", 15.0, 180.0);
			A("calm_heart", 3.0, 70.0);
			A("patient_recovery", 3.0, 70.0);
			A("deep_breath", 3.0, 70.0);
			A("steady_foothold", 3.0, 60.0);
			C("steady_foothold", 4.0, 75.0);
			A("travelers_vigor", 3.0, 60.0);
			A("thors_judgment", 20.0, 650.0);
			C("thors_judgment", 2.5, 40.0);
			A("fenrirs_hunger", 0.5, 18.0);
			A("fatebreaker", 10.0, 550.0);
			P("fatebreaker", "boss", 3.0, 200.0);
			C("fatebreaker", 2.0, 60.0);
			A("phantom_strike", 10.0, 500.0);
			P("phantom_strike", "chance", 2.0, 65.0);
			C("phantom_strike", 1.0, 35.0);
			A("winter_sovereign", 15.0, 600.0);
			C("winter_sovereign", 3.0, 65.0);
			A("runic_echo", 10.0, 450.0);
			C("runic_echo", 2.0, 50.0);
			A("ymirs_awakening", 50.0, 900.0);
			C("ymirs_awakening", 3.0, 75.0);
			A("earths_bounty", 5.0, 225.0);
			A("eternal_temper", 25.0, 99.0);
			A("tireless_creator", 5.0, 95.0);
			P("tireless_creator", "chance", 2.0, 80.0);
			A("runic_momentum", 2.0, 80.0);
			C("runic_momentum", 3.0, 75.0);
			A("worldsmith", 2.0, 20.0);
			C("worldsmith", 1.0, 45.0);
			A("freyrs_garden", 5.0, 80.0);
			A("aegirs_favor", 2.0, 90.0);
			A("yggdrasils_shelter", 5.0, 90.0);
			C("yggdrasils_shelter", 10.0, 240.0);
			A("bifrost_stride", 3.0, 60.0);
			P("bifrost_stride", "reduction", 5.0, 85.0);
			C("bifrost_stride", 1.0, 45.0);
			A("einherjars_return", 5.0, 90.0);
			C("einherjars_return", 600.0, 3600.0);
			A("heimdalls_bastion", 5.0, 90.0);
			C("heimdalls_bastion", 5.0, 120.0);
			A("guardians_wrath", 10.0, 450.0);
			C("guardians_wrath", 1.5, 40.0);
			A("runic_rebound", 10.0, 500.0);
			C("runic_rebound", 2.0, 60.0);
			A("fates_renewal", 5.0, 90.0);
			C("fates_renewal", 5.0, 120.0);
			A("ancient_resolve", 2.0, 70.0);
			C("ancient_resolve", 5.0, 120.0);
			A("travelers_mercy", 0.2, 3.0);
			C("travelers_mercy", 0.75, 60.0);
			A("norns_respite", 5.0, 350.0);
			A("undying_tenacity", 2.0, 70.0);
			A("dulled", 1.0, 32.0);
			A("faded_runes", 1.0, 32.0);
			A("exhausting", 1.0, 35.0);
			A("sluggish", 0.25, 15.0);
			A("brittle", 3.0, 65.0);
			A("heavy", 2.0, 100.0);
			A("restrictive", 0.25, 8.0);
			A("poor_guard", 1.0, 35.0);
			A("thin_plating", 1.0, 25.0);
			A("draining", 0.25, 15.0);
			A("frail", 0.25, 15.0);
			A("tiring", 1.0, 25.0);
			A("unbalanced", 1.0, 45.0);
			A("short_reach", 1.0, 30.0);
			A("slow_mending", 1.0, 25.0);
			A("burdened", 1.0, 25.0);
			A("vulnerable", 0.5, 18.0);
			A("runic_leak", 1.0, 35.0);
			return result;
			void A(string id, double min, double max)
			{
				result.Add(id + ".amount", (min, max));
			}
			void C(string id, double min, double max)
			{
				P(id, "cooldown", min, max);
			}
			void P(string id, string parameter, double min, double max)
			{
				result.Add(id + "." + parameter, (min, max));
			}
		}
	}
	public static class Balance021
	{
		public const string Version = "0.2.1";

		public const int GameplayPrecision = 3;

		private static readonly HashSet<string> HighRankParameters;

		static Balance021()
		{
			HighRankParameters = new HashSet<string>(StringComparer.Ordinal);
			string[] array = "razor_edge,runic_potency,punishing_blows,crushing_force,duelists_guard,reinforced,frostbound,emberbound,resource_breaker,extended_reach,haulers_strength,builders_reach,long_cast,fortified,vitality,endurance,runic_reservoir,recovery,second_wind,runic_flow,stormspark,executioner,veinbreaker,emergency_ward,runic_guard,calm_heart,patient_recovery,deep_breath,travelers_vigor,thors_judgment,fatebreaker,phantom_strike,winter_sovereign,runic_echo,ymirs_awakening,yggdrasils_shelter,heimdalls_bastion,guardians_wrath,runic_rebound,norns_respite,work_breath,work_reserve,steady_supplies,breath_of_hearth,guard_focus,storm_step,opening_cut,desperate_edge,farshot,point_blank,ambushers_edge,retaliation_edge,guardbreaker,spellbattery,followthrough,tyrs_measure,bloodstar,flanking_edge,dueling_edge,surrounded_edge,relentless_edge,grounded_impact,highground,giant_hunter,airborne_hunter,steady_release,pinning_shot,shield_rebuke,parry_riposte,wet_conduit,cinder_hunter,frozen_focus,arcane_precision,soul_shelter".Split(',');
			foreach (string text in array)
			{
				HighRankParameters.Add(text + ".amount");
			}
			HighRankParameters.Add("fatebreaker.boss");
		}

		public static bool AllowsHighRankMaximum(string definitionId, string parameterId)
		{
			return HighRankParameters.Contains(definitionId + "." + parameterId);
		}

		public static void Apply(IReadOnlyList<PerkDefinition> definitions)
		{
			Dictionary<string, double> dictionary = ReviewedMaxima();
			int num = 0;
			foreach (PerkDefinition definition in definitions)
			{
				foreach (PerkParameter parameter in definition.Parameters)
				{
					if (dictionary.TryGetValue(definition.Id + "." + parameter.Id, out var value))
					{
						if (parameter.Unit != "%" || value < parameter.Max)
						{
							throw new InvalidOperationException("Invalid reviewed 0.2.1 percentage maximum: " + definition.Id + "." + parameter.Id);
						}
						parameter.Max = value;
						num++;
					}
					parameter.Precision = 3;
					if (AllowsHighRankMaximum(definition.Id, parameter.Id))
					{
						if (definition.Class == PerkClass.Negative || parameter.Unit != "%" || !parameter.HigherIsBetter)
						{
							throw new InvalidOperationException("Invalid high-rank percentage contract: " + definition.Id + "." + parameter.Id);
						}
						parameter.HighRankMaxima = new Dictionary<int, double>
						{
							[9] = parameter.Max * 1.5,
							[10] = parameter.Max * 2.0,
							[11] = parameter.Max * 2.5,
							[12] = parameter.Max * 3.0
						};
					}
				}
			}
			if (num != dictionary.Count)
			{
				throw new InvalidOperationException("The 0.2.1 balance table contains an unused parameter maximum.");
			}
		}

		public static Dictionary<string, double> ReviewedMaxima()
		{
			return new Dictionary<string, double>(StringComparer.Ordinal)
			{
				["razor_edge.amount"] = 150.0,
				["runic_potency.amount"] = 144.0,
				["efficient_strikes.amount"] = 85.0,
				["quickstrike.amount"] = 75.0,
				["quick_draw.amount"] = 90.0,
				["rapid_reload.amount"] = 85.0,
				["steady_aim.amount"] = 85.0,
				["eitr_efficiency.amount"] = 85.0,
				["punishing_blows.amount"] = 165.0,
				["crushing_force.amount"] = 150.0,
				["duelists_guard.amount"] = 150.0,
				["reinforced.amount"] = 660.0,
				["lightweight.amount"] = 80.0,
				["frostbound.amount"] = 84.0,
				["emberbound.amount"] = 84.0,
				["resource_breaker.amount"] = 195.0,
				["efficient_labor.amount"] = 85.0,
				["swift_labor.amount"] = 90.0,
				["resource_magnet.amount"] = 540.0,
				["extended_reach.amount"] = 165.0,
				["haulers_strength.amount"] = 105.0,
				["builders_reach.amount"] = 210.0,
				["green_hands.amount"] = 85.0,
				["patient_angler.amount"] = 85.0,
				["long_cast.amount"] = 165.0,
				["fortified.amount"] = 90.0,
				["vitality.amount"] = 66.0,
				["endurance.amount"] = 75.0,
				["runic_reservoir.amount"] = 90.0,
				["recovery.amount"] = 150.0,
				["second_wind.amount"] = 150.0,
				["runic_flow.amount"] = 150.0,
				["fleetfoot.amount"] = 36.0,
				["tireless.amount"] = 85.0,
				["nimble.amount"] = 85.0,
				["springstep.amount"] = 85.0,
				["riverstride.amount"] = 85.0,
				["quiet_steps.amount"] = 85.0,
				["ward_fire.amount"] = 60.0,
				["ward_frost.amount"] = 60.0,
				["ward_lightning.amount"] = 48.0,
				["ward_poison.amount"] = 48.0,
				["ward_spirit.amount"] = 48.0,
				["ward_blunt.amount"] = 48.0,
				["ward_slash.amount"] = 48.0,
				["ward_pierce.amount"] = 48.0,
				["soft_landing.amount"] = 85.0,
				["efficient_guard.amount"] = 85.0,
				["firm_grip.amount"] = 80.0,
				["stormspark.amount"] = 300.0,
				["executioner.amount"] = 195.0,
				["runic_reserve.amount"] = 100.0,
				["veinbreaker.amount"] = 660.0,
				["natures_favor.amount"] = 195.0,
				["emergency_ward.amount"] = 105.0,
				["windstep.amount"] = 65.0,
				["runic_guard.amount"] = 90.0,
				["second_breath.amount"] = 100.0,
				["calm_heart.amount"] = 210.0,
				["patient_recovery.amount"] = 210.0,
				["deep_breath.amount"] = 210.0,
				["steady_foothold.amount"] = 75.0,
				["travelers_vigor.amount"] = 180.0,
				["thors_judgment.amount"] = 1950.0,
				["fenrirs_hunger.amount"] = 54.0,
				["fatebreaker.amount"] = 1650.0,
				["fatebreaker.boss"] = 600.0,
				["phantom_strike.amount"] = 1500.0,
				["phantom_strike.chance"] = 99.0,
				["winter_sovereign.amount"] = 1800.0,
				["runic_echo.amount"] = 1350.0,
				["ymirs_awakening.amount"] = 2700.0,
				["earths_bounty.amount"] = 250.0,
				["eternal_temper.amount"] = 99.0,
				["tireless_creator.amount"] = 100.0,
				["tireless_creator.chance"] = 99.0,
				["runic_momentum.amount"] = 90.0,
				["freyrs_garden.amount"] = 85.0,
				["aegirs_favor.amount"] = 99.0,
				["yggdrasils_shelter.amount"] = 270.0,
				["bifrost_stride.amount"] = 65.0,
				["bifrost_stride.reduction"] = 85.0,
				["einherjars_return.amount"] = 100.0,
				["heimdalls_bastion.amount"] = 270.0,
				["guardians_wrath.amount"] = 1350.0,
				["runic_rebound.amount"] = 1500.0,
				["fates_renewal.amount"] = 100.0,
				["ancient_resolve.amount"] = 75.0,
				["travelers_mercy.amount"] = 3.0,
				["norns_respite.amount"] = 1050.0,
				["undying_tenacity.amount"] = 75.0,
				["dulled.amount"] = 64.0,
				["faded_runes.amount"] = 64.0,
				["exhausting.amount"] = 70.0,
				["sluggish.amount"] = 30.0,
				["brittle.amount"] = 80.0,
				["heavy.amount"] = 200.0,
				["restrictive.amount"] = 16.0,
				["poor_guard.amount"] = 70.0,
				["thin_plating.amount"] = 50.0,
				["draining.amount"] = 30.0,
				["frail.amount"] = 30.0,
				["tiring.amount"] = 50.0,
				["unbalanced.amount"] = 90.0,
				["short_reach.amount"] = 60.0,
				["slow_mending.amount"] = 50.0,
				["burdened.amount"] = 50.0,
				["vulnerable.amount"] = 36.0,
				["runic_leak.amount"] = 70.0,
				["work_stride.amount"] = 54.0,
				["work_breath.amount"] = 180.0,
				["work_reserve.amount"] = 90.0,
				["pack_frame.amount"] = 75.0,
				["work_recovery.amount"] = 85.0,
				["tool_grace.amount"] = 85.0,
				["tool_care.amount"] = 80.0,
				["supply_sense.amount"] = 600.0,
				["measured_work.amount"] = 85.0,
				["rhythmic_work.amount"] = 100.0,
				["craftsman_trance.amount"] = 85.0,
				["field_second_wind.amount"] = 100.0,
				["steady_supplies.amount"] = 360.0,
				["repairing_touch.amount"] = 54.0,
				["rough_care.amount"] = 130.0,
				["fumbling.amount"] = 120.0,
				["short_breath.amount"] = 50.0,
				["overpacked.amount"] = 50.0,
				["muffled_steps.amount"] = 80.0,
				["shadowweave.amount"] = 75.0,
				["featherbound.amount"] = 150.0,
				["slow_feast.amount"] = 100.0,
				["rain_shedding.amount"] = 85.0,
				["camp_memory.amount"] = 100.0,
				["measured_parry.amount"] = 80.0,
				["longstride.amount"] = 85.0,
				["rainwalker.amount"] = 65.0,
				["anchor_stance.amount"] = 85.0,
				["breath_of_hearth.amount"] = 480.0,
				["guard_focus.amount"] = 480.0,
				["skyward_leap.amount"] = 150.0,
				["oathkeepers_reserve.amount"] = 240.0,
				["storm_step.amount"] = 900.0,
				["valkyrie_poise.amount"] = 85.0,
				["opening_cut.amount"] = 195.0,
				["desperate_edge.amount"] = 210.0,
				["farshot.amount"] = 225.0,
				["point_blank.amount"] = 150.0,
				["ambushers_edge.amount"] = 180.0,
				["retaliation_edge.amount"] = 360.0,
				["guardbreaker.amount"] = 300.0,
				["spellbattery.amount"] = 300.0,
				["followthrough.amount"] = 360.0,
				["tyrs_measure.amount"] = 1500.0,
				["bloodstar.amount"] = 750.0,
				["runesurge.amount"] = 100.0,
				["quiet_construction.amount"] = 80.0,
				["careful_demolition.amount"] = 85.0,
				["leveling_focus.amount"] = 85.0,
				["raising_focus.amount"] = 85.0,
				["seed_focus.amount"] = 85.0,
				["cultivation_focus.amount"] = 85.0,
				["luring_glimmer.amount"] = 150.0,
				["hook_window.amount"] = 200.0,
				["bait_keeper.amount"] = 99.0,
				["restoration_reserve.amount"] = 100.0,
				["fortress_oath.amount"] = 75.0,
				["weatherseal.amount"] = 95.0,
				["artisan_renewal.amount"] = 100.0,
				["verdant_clock.amount"] = 85.0,
				["deep_roots.amount"] = 35.0,
				["harvest_moon.amount"] = 80.0,
				["unbroken_line.amount"] = 250.0,
				["stillwater_pact.amount"] = 85.0,
				["tidal_memory.amount"] = 100.0,
				["hooked_fortune.amount"] = 99.0,
				["earthshaper.amount"] = 180.0,
				["stoneweaver.amount"] = 250.0,
				["pathfinder.amount"] = 250.0,
				["terraced_wisdom.amount"] = 180.0
			};
		}
	}
	public static class CompactPerkDescriptions
	{
		private static readonly IReadOnlyDictionary<string, string> Templates = CreateTemplates();

		public static string Template(PerkDefinition def)
		{
			if (def == null)
			{
				throw new ArgumentNullException("def");
			}
			if (def.DefinitionVersion != 1 || !Templates.TryGetValue(def.Id, out string value))
			{
				return def.Trigger;
			}
			return PercentageText.Normalize(value);
		}

		private static IReadOnlyDictionary<string, string> CreateTemplates()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.Ordinal)
			{
				["razor_edge"] = "+{amount}% physical damage",
				["runic_potency"] = "+{amount}% existing elemental damage",
				["efficient_strikes"] = "-{amount}% attack stamina cost",
				["quickstrike"] = "+{amount}% melee attack speed",
				["quick_draw"] = "+{amount}% bow draw speed",
				["rapid_reload"] = "-{amount}% crossbow reload time",
				["steady_aim"] = "-{amount}% aiming stamina cost",
				["eitr_efficiency"] = "-{amount}% Eitr cost",
				["punishing_blows"] = "+{amount}% direct damage vs staggered enemies",
				["crushing_force"] = "+{amount}% direct-hit stagger",
				["duelists_guard"] = "+{amount}% block power",
				["reinforced"] = "+{amount}% max durability",
				["lightweight"] = "-{amount}% item weight",
				["frostbound"] = "+{amount}% base damage as Frost",
				["emberbound"] = "+{amount}% base damage as Fire",
				["resource_breaker"] = "+{amount}% gathering damage",
				["efficient_labor"] = "-{amount}% work stamina cost",
				["swift_labor"] = "+{amount}% work, build and reel speed",
				["resource_magnet"] = "+{amount}% wood/stone/ore pickup radius while held",
				["extended_reach"] = "+{amount}% tool reach",
				["haulers_strength"] = "+{amount}% base carry capacity",
				["builders_reach"] = "+{amount}% build/repair reach",
				["green_hands"] = "-{amount}% planting stamina cost",
				["patient_angler"] = "-{amount}% reeling stamina cost",
				["long_cast"] = "+{amount}% cast distance and line length",
				["fortified"] = "+{amount}% Armor",
				["vitality"] = "+{amount}% max HP from base + food",
				["endurance"] = "+{amount}% max stamina from base + food",
				["runic_reservoir"] = "+{amount}% existing food Eitr",
				["recovery"] = "+{amount}% HP regen",
				["second_wind"] = "+{amount}% stamina regen",
				["runic_flow"] = "+{amount}% Eitr regen",
				["fleetfoot"] = "+{amount}% walk/run speed",
				["tireless"] = "-{amount}% sprint stamina cost",
				["nimble"] = "-{amount}% dodge stamina cost",
				["springstep"] = "-{amount}% jump stamina cost",
				["riverstride"] = "-{amount}% swim stamina cost",
				["quiet_steps"] = "-{amount}% sneak stamina cost",
				["soft_landing"] = "-{amount}% fall damage",
				["efficient_guard"] = "-{amount}% block stamina cost",
				["firm_grip"] = "-{amount}% knockback taken while blocking",
				["stormspark"] = "Direct hit: chain {amount}% damage to 1 enemy within 8m; CD {cooldown}s",
				["executioner"] = "+{amount}% direct damage vs enemies below 20% HP",
				["runic_reserve"] = "Every 5th manual spell: refund {amount}% Eitr spent",
				["veinbreaker"] = "Every 6th gather hit: +{amount}% gathering damage",
				["natures_favor"] = "+{amount}% average natural-resource yield on first drops",
				["master_repair"] = "Repair up to 3 owned pieces within {amount}m; CD {cooldown}s",
				["emergency_ward"] = "Hit leaves HP below 30%: {amount}% max-HP barrier for 4s; CD {cooldown}s",
				["windstep"] = "Dodge: +{amount}% movement for 2s; CD {cooldown}s",
				["runic_guard"] = "Block: {amount}% max-HP barrier for 4s; CD {cooldown}s",
				["second_breath"] = "Below 20% stamina: restore {amount}% max stamina; CD {cooldown}s",
				["calm_heart"] = "8s unharmed: +{amount}% HP regen",
				["patient_recovery"] = "Below 50% HP: +{amount}% HP regen",
				["deep_breath"] = "Below 40% stamina: +{amount}% stamina regen",
				["steady_foothold"] = "Taking damage: -{amount}% stagger taken for 4s; CD {cooldown}s",
				["travelers_vigor"] = "Above 80% HP: +{amount}% stamina regen",
				["thors_judgment"] = "Every 6th direct hit: {amount}% lightning damage, up to 3 enemies/8m; CD {cooldown}s",
				["fenrirs_hunger"] = "Heal {amount}% of direct damage dealt; shared cap 3% max HP/s",
				["fatebreaker"] = "+{amount}% direct damage vs enemies below 30% HP (bosses +{boss}%); CD {cooldown}s",
				["phantom_strike"] = "Direct hit: {chance}% chance of {amount}% extra damage; CD {cooldown}s",
				["winter_sovereign"] = "Every 8th direct hit: {amount}% frost damage in 5m; CD {cooldown}s",
				["runic_echo"] = "Every 4th manual offensive cast: repeat {amount}% direct damage; CD {cooldown}s",
				["ymirs_awakening"] = "Every 8th gather hit: {amount}% gathering damage in 3m; CD {cooldown}s",
				["earths_bounty"] = "+{amount}% average natural-resource yield on first drops",
				["eternal_temper"] = "{amount}% chance to avoid durability loss",
				["tireless_creator"] = "Successful work: {chance}% chance to refund {amount}% stamina spent",
				["runic_momentum"] = "Every 5th successful work action: +{amount}% work speed for 6s; CD {cooldown}s",
				["worldsmith"] = "Repair up to 10 owned pieces within {amount}m; CD {cooldown}s",
				["freyrs_garden"] = "Left Shift: plant 3x3, -{amount}% total stamina cost; needs all seeds",
				["aegirs_favor"] = "Catch: {amount}% chance of 1 extra matching fish",
				["yggdrasils_shelter"] = "Hit leaves HP below 35%: {amount}% max-HP barrier for 6s; CD {cooldown}s",
				["bifrost_stride"] = "Dodge: +{amount}% movement for 3s, next dodge cost -{reduction}%; CD {cooldown}s",
				["einherjars_return"] = "Survive lethal hit at {amount}% max HP + 2s protection; shared CD {cooldown}s",
				["heimdalls_bastion"] = "3 blocks in 5s: {amount}% max-HP barrier for 6s; CD {cooldown}s",
				["guardians_wrath"] = "Block: next direct melee hit within 3s deals +{amount}%; CD {cooldown}s",
				["runic_rebound"] = "Block enemy projectile: reflect {amount}% incoming damage; CD {cooldown}s",
				["fates_renewal"] = "Below 15% stamina: restore {amount}% max stamina; CD {cooldown}s",
				["ancient_resolve"] = "Taking damage: -{amount}% damage taken for 4s; CD {cooldown}s",
				["travelers_mercy"] = "Dodge: heal {amount}% max HP (shared cap 3%/s); CD {cooldown}s",
				["norns_respite"] = "12s unharmed: +{amount}% HP regen",
				["undying_tenacity"] = "Below 30% HP: -{amount}% stagger taken",
				["dulled"] = "-{amount}% physical/gathering damage",
				["faded_runes"] = "-{amount}% existing elemental spell damage",
				["exhausting"] = "+{amount}% stamina costs",
				["sluggish"] = "-{amount}% attack/work animation speed",
				["brittle"] = "-{amount}% max durability",
				["heavy"] = "+{amount}% item weight",
				["restrictive"] = "-{amount}% movement speed",
				["poor_guard"] = "-{amount}% block power",
				["thin_plating"] = "-{amount}% Armor",
				["draining"] = "-{amount}% max stamina from base + food",
				["frail"] = "-{amount}% max HP from base + food",
				["tiring"] = "-{amount}% stamina regen",
				["unbalanced"] = "+{amount}% knockback taken",
				["short_reach"] = "-{amount}% tool reach",
				["slow_mending"] = "-{amount}% HP regen",
				["burdened"] = "-{amount}% base carry capacity",
				["vulnerable"] = "+{amount}% physical damage taken after resistance",
				["runic_leak"] = "+{amount}% Eitr costs",
				["work_stride"] = "Successful work: +{amount}% movement for 8s with same tool",
				["work_breath"] = "Successful work: +{amount}% stamina regen for 8s with same tool",
				["work_reserve"] = "+{amount}% max stamina from base + food while held",
				["pack_frame"] = "-{amount}% materials/seed/bait/fish weight while held",
				["work_recovery"] = "Successful work: -{amount}% remaining stamina regen delay",
				["tool_grace"] = "-{amount}% tool equip/sheathe time",
				["tool_care"] = "-{amount}% tool durability loss",
				["supply_sense"] = "+{amount}% materials/seed/bait/fish pickup radius while held",
				["measured_work"] = "After 3 work successes: -{amount}% work cost; resets on swap/10s idle",
				["rhythmic_work"] = "Every 3rd work success: refund {amount}% stamina spent",
				["craftsman_trance"] = "Every 6th work success: next 3 work costs -{amount}%; CD {cooldown}s; reset on swap/10s idle",
				["field_second_wind"] = "Every 8th work success: restore {amount}% max stamina; CD {cooldown}s",
				["steady_supplies"] = "Every 8th work success: +{amount}% carry capacity for 12s with same tool; CD {cooldown}s",
				["repairing_touch"] = "Every 10th work success: repair {amount}% missing tool durability; CD {cooldown}s",
				["tool_courier"] = "Every 8th work success: pull up to 24 supplies within {amount}m; CD {cooldown}s",
				["rough_care"] = "+{amount}% tool durability loss",
				["fumbling"] = "+{amount}% tool equip/sheathe time",
				["short_breath"] = "Successful work: -{amount}% stamina regen for 8s with same tool",
				["overpacked"] = "+{amount}% materials/seed/bait/fish weight while held",
				["muffled_steps"] = "-{amount}% noise radius (80% cap)",
				["shadowweave"] = "-{amount}% visibility while sneaking (75% cap)",
				["featherbound"] = "+{amount}% jump height (150% cap)",
				["slow_feast"] = "+{amount}% food duration (100% cap)",
				["rain_shedding"] = "-{amount}% Wet duration (85% cap)",
				["camp_memory"] = "+{amount}% next Rested duration (100% cap)",
				["measured_parry"] = "+{amount}% shield parry bonus (80% cap)",
				["longstride"] = "Running for 4s: -{amount}% jump stamina cost",
				["rainwalker"] = "While Wet: +{amount}% movement speed",
				["anchor_stance"] = "After blocking still for 1.5s: -{amount}% block cost",
				["breath_of_hearth"] = "While Resting: +{amount}% HP regen",
				["guard_focus"] = "Block: +{amount}% stamina regen for 6s; CD {cooldown}s",
				["skyward_leap"] = "1 extra jump/landing, +{amount}% height (150% cap); stamina required; CD {cooldown}s",
				["oathkeepers_reserve"] = "Block: gain {amount}% blocked damage as stamina (15% max-stamina cap); CD {cooldown}s",
				["storm_step"] = "Dodge: +{amount}% stamina regen for 4s; CD {cooldown}s",
				["valkyrie_poise"] = "-{amount}% fall damage; 30% prevented damage to stamina (20% max cap); refund CD {cooldown}s",
				["opening_cut"] = "+{amount}% direct damage vs targets above 90% HP",
				["desperate_edge"] = "Below 25% stamina: +{amount}% direct damage",
				["farshot"] = "+{amount}% direct projectile damage at 15m+ from launch",
				["point_blank"] = "+{amount}% direct projectile damage within 5m of launch",
				["ambushers_edge"] = "+{amount}% direct damage vs unalerted enemies",
				["retaliation_edge"] = "After taking HP damage: +{amount}% direct damage for 4s",
				["guardbreaker"] = "+{amount}% direct damage vs blocking humanoids",
				["spellbattery"] = "Above 80% Eitr: +{amount}% direct spell damage",
				["followthrough"] = "Direct hit: next direct hit on a different enemy within 3s deals +{amount}%",
				["tyrs_measure"] = "Below 50% HP: +{amount}% direct boss damage; CD {cooldown}s",
				["bloodstar"] = "Direct enemy kill: +{amount}% direct damage for 6s; no buffed-kill refresh; CD {cooldown}s",
				["runesurge"] = "Direct spell hit: refund {amount}% Eitr spent (20% max Eitr/cast cap); CD {cooldown}s",
				["quiet_construction"] = "-{amount}% build/repair/demolition noise",
				["careful_demolition"] = "-{amount}% successful demolition stamina cost",
				["leveling_focus"] = "-{amount}% level-ground stamina cost",
				["raising_focus"] = "-{amount}% raise-ground stamina cost",
				["seed_focus"] = "-{amount}% planting stamina cost",
				["cultivation_focus"] = "-{amount}% cultivation stamina cost",
				["luring_glimmer"] = "+{amount}% fish attraction radius; correct bait required",
				["hook_window"] = "+{amount}% manual hook window (base 0.5s); correct bait",
				["bait_keeper"] = "Catch: {amount}% chance to return 1 bait used",
				["restoration_reserve"] = "Manual repair: restore {amount}% max stamina; CD {cooldown}s",
				["fortress_oath"] = "New owned pieces take {amount}% less hit damage (75% cap)",
				["weatherseal"] = "New owned pieces take {amount}% less weather damage; need support",
				["artisan_renewal"] = "Manual repair: restore {amount}% missing hammer durability; CD {cooldown}s",
				["verdant_clock"] = "New plants: -{amount}% growth time (85% cap); normal growing conditions",
				["deep_roots"] = "New plants: -{amount}% spacing radius (35% cap); normal growing conditions",
				["harvest_moon"] = "Plant: advance up to 6 nearby owned healthy plants by {amount}% base growth; CD {cooldown}s",
				["unbroken_line"] = "+{amount}% line stretch before breaking",
				["stillwater_pact"] = "Hooked fish struggling: -{amount}% fishing stamina cost",
				["tidal_memory"] = "Catch: restore {amount}% max stamina; CD {cooldown}s",
				["hooked_fortune"] = "Correct-bait nibble: {amount}% auto-hook chance; reel normally; CD {cooldown}s",
				["earthshaper"] = "+{amount}% level-ground radius (8m cap); whole area needs permission",
				["stoneweaver"] = "+{amount}% height per paid raise-ground action; native terrain limits",
				["pathfinder"] = "+{amount}% paint-ground radius (8m cap); whole area needs permission",
				["terraced_wisdom"] = "+{amount}% smoothing radius (8m cap); whole area needs permission",
				["flanking_edge"] = "+{amount}% direct melee damage from rear 120-degree arc",
				["dueling_edge"] = "+{amount}% direct melee damage vs sole enemy within 6m",
				["surrounded_edge"] = "3+ enemies within 8m: +{amount}% direct melee damage",
				["relentless_edge"] = "+{amount}% direct melee damage vs last directly hit enemy for 3s; no stacking",
				["grounded_impact"] = "+{amount}% melee knockback vs grounded enemies",
				["martial_rhythm"] = "Every 3rd paid melee attack with direct damage: refund {amount}% stamina spent (85% cap)",
				["highground"] = "+{amount}% direct projectile damage launched 3m+ above impact",
				["giant_hunter"] = "+{amount}% direct projectile damage vs enemies with 3x your max HP",
				["airborne_hunter"] = "+{amount}% direct projectile damage vs airborne enemies; not swimmers",
				["steady_release"] = "At impact: above 50% stamina + 8s unharmed, +{amount}% direct projectile damage",
				["pinning_shot"] = "+{amount}% projectile stagger at 15m+ from launch; no extra HP damage",
				["shield_breath"] = "Enemy block: refund {amount}% block stamina spent (85% cap); CD {cooldown}s",
				["shield_mending"] = "Enemy block: repair {amount}% missing shield durability; CD {cooldown}s",
				["shield_rebuke"] = "Enemy melee block: return {amount}% blocked damage as Frost; CD {cooldown}s",
				["shield_composure"] = "Enemy projectile block: -{amount}% stamina regen delay (85% cap); CD {cooldown}s",
				["parry_riposte"] = "Parry: +{amount}% direct melee damage for 4s with same shield; CD {cooldown}s",
				["wet_conduit"] = "+{amount}% direct spell damage vs Wet enemies",
				["cinder_hunter"] = "+{amount}% direct spell damage vs Burning enemies",
				["frozen_focus"] = "+{amount}% direct spell damage vs Frost-slowed enemies",
				["arcane_precision"] = "At impact: above 75% HP + 50% Eitr, +{amount}% direct spell damage",
				["spell_repair"] = "Direct spell hit: repair {amount}% missing staff durability; CD {cooldown}s",
				["sorcerers_breath"] = "Direct spell kill: restore {amount}% max stamina; no DOT/procs; CD {cooldown}s",
				["soul_shelter"] = "Direct spell kill: {amount}% max-HP barrier for 6s, strongest only; no DOT/procs; CD {cooldown}s"
			};
			string[] array = new string[8] { "fire", "frost", "lightning", "poison", "spirit", "blunt", "slash", "pierce" };
			foreach (string text in array)
			{
				dictionary.Add("ward_" + text, "-{amount}% incoming " + text + " damage after resistance");
			}
			foreach (ExpansionPerk value in Expansion045.Details.Values)
			{
				dictionary.Add(value.Definition.Id, value.Compact);
			}
			return dictionary;
		}
	}
	public static class ConfigurationValidator
	{
		public static List<string> Validate(GameplayConfig config, IEnumerable<ItemProfile>? profiles = null, bool requireDiversePools = true)
		{
			List<string> list = new List<string>();
			if (config.SchemaVersion != 1)
			{
				list.Add("Unsupported gameplay configuration schema.");
			}
			if (config.PerkPlacementVersion < 0 || config.PerkPlacementVersion > 1)
			{
				list.Add("Unsupported perk placement policy version.");
			}
			if (config.Rarities == null || config.StrengthBands == null || config.Perks == null || config.Limits == null || config.ItemOverrides == null || config.Forge == null)
			{
				list.Add("Configuration tables must not be null.");
				return list;
			}
			if (config.Rarities.Any((RarityDefinition r) => r == null) || config.StrengthBands.Any((StrengthBand b) => b == null) || config.Perks.Any((PerkDefinition p) => p == null) || config.ItemOverrides.Any((ItemOverride o) => o == null))
			{
				list.Add("Configuration tables must not contain null entries.");
				return list;
			}
			bool flag = config.Rarities.Any((RarityDefinition r) => r.Rank == 0);
			if (config.Forge.SalvageReturnPercent < 0 || config.Forge.SalvageReturnPercent > 50)
			{
				list.Add("Forge salvage return percentage must be between 0 and 50.");
			}
			if (config.Rarities.Count != (flag ? 19 : 18))
			{
				list.Add("The full 18 nonzero rarities are required, optionally with rank-zero Default as a nineteenth outcome.");
			}
			if (((IEnumerable<RarityDefinition>)config.Rarities).Sum((Func<RarityDefinition, long>)((RarityDefinition r) => r.Weight)) != 10000)
			{
				list.Add("Rarity weights must total exactly 10,000; automatic normalization is forbidden.");
			}
			if (config.Rarities.Select((RarityDefinition r) => r.Id).Distinct<string>(StringComparer.Ordinal).Count() != config.Rarities.Count)
			{
				list.Add("Rarity IDs must be unique.");
			}
			if (config.Rarities.Select((RarityDefinition r) => r.Rank).Distinct().Count() != config.Rarities.Count)
			{
				list.Add("Rarity ranks must be unique.");
			}
			foreach (RarityDefinition rarity in config.Rarities)
			{
				if (string.IsNullOrWhiteSpace(rarity.Id) || string.IsNullOrWhiteSpace(rarity.Name))
				{
					list.Add("Rarity IDs and names must be present.");
				}
				if (rarity.Weight < 0 || rarity.Rank < -6 || rarity.Rank > 12)
				{
					list.Add("Invalid rarity weight or rank: " + rarity.Id);
				}
				if (rarity.Rank == 0 != (rarity.Id == "default"))
				{
					list.Add("Only Default may use rank zero: " + rarity.Id);
				}
				if (PerkSelector.Slots(rarity).Any((int n) => n < 0 || n > 12) || ((IEnumerable<int>)PerkSelector.Slots(rarity)).Sum((Func<int, long>)((int n) => n)) != Math.Abs((long)rarity.Rank))
				{
					list.Add("Perk allocation must equal absolute rarity rank: " + rarity.Id);
				}
				if ((rarity.Rank < 0 && rarity.NegativeSlots != -rarity.Rank) || (rarity.Rank > 0 && rarity.NegativeSlots != 0))
				{
					list.Add("Only negative rarities allocate penalties: " + rarity.Id);
				}
				if (rarity.UltraSlots > 0 && rarity.Rank < 9)
				{
					list.Add("Ultra perks require rarity rank +9 or higher.");
				}
				if (!Regex.IsMatch(rarity.Color ?? "", "^#[0-9a-fA-F]{6}$"))
				{
					list.Add("Invalid rarity color: " + rarity.Id);
				}
			}
			if (config.StrengthBands.Count == 0 || ((IEnumerable<StrengthBand>)config.StrengthBands).Sum((Func<StrengthBand, long>)((StrengthBand b) => b.Weight)) != 10000)
			{
				list.Add("Strength band weights must total exactly 10,000.");
			}
			int num = 0;
			foreach (StrengthBand strengthBand in config.StrengthBands)
			{
				if (strengthBand.MinScore != num || strengthBand.MaxScore < strengthBand.MinScore || strengthBand.MaxScore > 10000 || strengthBand.Weight < 0)
				{
					list.Add("Strength bands must cover scores 0–10000 exactly once in order, without gaps or overlap.");
				}
				num = strengthBand.MaxScore + 1;
			}
			if (num != 10001)
			{
				list.Add("Strength bands must include the exact score 10000.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (PerkDefinition perk in config.Perks)
			{
				if (!hashSet.Add(perk.Id) || string.IsNullOrWhiteSpace(perk.Id))
				{
					list.Add("Missing or duplicate perk ID: " + perk.Id);
				}
				if (string.IsNullOrWhiteSpace(perk.Name) || string.IsNullOrWhiteSpace(perk.Effect) || string.IsNullOrWhiteSpace(perk.Trigger) || string.IsNullOrWhiteSpace(perk.Stacking) || string.IsNullOrWhiteSpace(perk.SafetyLimits))
				{
					list.Add("Perk must declare its name, implemented effect, trigger, stacking, and safety rules: " + perk.Id);
				}
				if (perk.Weight < 0 || perk.DefinitionVersion < 1 || !Enum.IsDefined(typeof(PerkClass), perk.Class))
				{
					list.Add("Invalid perk weight, class, or definition version: " + perk.Id);
				}
				if (perk.Categories == null || perk.RequiredCapabilities == null || perk.ExcludedNativeEffects == null || perk.ExclusionGroups == null || perk.IncompatibleIds == null || perk.Parameters == null)
				{
					list.Add("Perk metadata collections must be defined: " + perk.Id);
					continue;
				}
				if (perk.Parameters.Count == 0)
				{
					list.Add("Every perk requires a randomized numerical parameter: " + perk.Id);
				}
				HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
				foreach (PerkParameter parameter in perk.Parameters)
				{
					if (parameter == null)
					{
						list.Add("Perk parameter must not be null: " + perk.Id);
						continue;
					}
					if (!hashSet2.Add(parameter.Id) || string.IsNullOrWhiteSpace(parameter.Id))
					{
						list.Add("Duplicate or absent parameter: " + perk.Id);
					}
					if (!Finite(parameter.Min) || !Finite(parameter.Max) || parameter.Min >= parameter.Max || parameter.Precision < 0 || parameter.Precision > 6 || string.IsNullOrWhiteSpace(parameter.Unit))
					{
						list.Add("Invalid randomized parameter range, precision, or unit: " + perk.Id + "." + parameter.Id);
					}
					if (parameter.HighRankMaxima == null)
					{
						list.Add("High-rank maxima must be an object, empty for untiered or historical ranges: " + perk.Id + "." + parameter.Id);
					}
					else
					{
						if (parameter.HighRankMaxima.Count <= 0)
						{
							continue;
						}
						if (parameter.HighRankMaxima.Count != 4)
						{
							list.Add("A high-rank maximum map must declare all four ranks 9 through 12, or be empty: " + perk.Id + "." + parameter.Id);
						}
						if (!Balance021.AllowsHighRankMaximum(perk.Id, parameter.Id) || perk.Class == PerkClass.Negative || parameter.Unit != "%" || !parameter.HigherIsBetter)
						{
							list.Add("High-rank maxima are only supported for reviewed uncapped beneficial percentages: " + perk.Id + "." + parameter.Id);
						}
						double num2 = parameter.Max;
						for (int num3 = 9; num3 <= 12; num3++)
						{
							if (parameter.HighRankMaxima.TryGetValue(num3, out var value))
							{
								if (!Finite(value) || value < num2 || value > 9000.0)
								{
									list.Add("High-rank maxima must be finite, nondecreasing, at least the base maximum and at most 9000: " + perk.Id + "." + parameter.Id);
								}
								num2 = value;
							}
						}
						if (parameter.HighRankMaxima.Keys.Any((int rank) => rank < 9 || rank > 12))
						{
							list.Add("High-rank maxima support only ranks 9 through 12: " + perk.Id + "." + parameter.Id);
						}
					}
				}
			}
			if (((IEnumerable<PerkDefinition>)config.Perks).Sum((Func<PerkDefinition, long>)((PerkDefinition p) => p.Weight)) > int.MaxValue)
			{
				list.Add("Perk weight total exceeds supported integer range.");
			}
			foreach (PerkDefinition item in config.Perks.Where((PerkDefinition p) => p.IncompatibleIds != null))
			{
				foreach (string incompatibleId in item.IncompatibleIds)
				{
					if (!hashSet.Contains(incompatibleId) || incompatibleId == item.Id)
					{
						list.Add("Unknown or self-referencing incompatible perk: " + item.Id + " -> " + incompatibleId);
					}
				}
			}
			BalanceLimits limits = config.Limits;
			double[] array = new double[6] { limits.MovementSpeedPercent, limits.AttackSpeedPercent, limits.CostReductionPercent, limits.DamageReductionPercent, limits.ResourceBonusPercent, limits.HealingMaxHealthPerSecondPercent };
			foreach (double num5 in array)
			{
				if (!Finite(num5) || num5 < 0.0 || num5 > 1000.0)
				{
					list.Add("Aggregate percent caps must be finite and between 0 and 1000.");
				}
			}
			if (limits.CostReductionPercent >= 100.0 || limits.DamageReductionPercent >= 100.0)
			{
				list.Add("Cost and damage reduction caps must be below 100%.");
			}
			if (!Finite(limits.StatFloorMultiplier) || limits.StatFloorMultiplier <= 0.0 || limits.StatFloorMultiplier > 1.0 || !Finite(limits.MaximumCostMultiplier) || limits.MaximumCostMultiplier < 1.0 || limits.MaximumCostMultiplier > 20.0)
			{
				list.Add("Stat floors and action-cost limits must preserve usable equipment.");
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			foreach (ItemOverride itemOverride in config.ItemOverrides)
			{
				if (string.IsNullOrWhiteSpace(itemOverride.Prefab) || !hashSet3.Add(itemOverride.Prefab) || (itemOverride.Enabled && string.IsNullOrWhiteSpace(itemOverride.Category)) || itemOverride.Capabilities == null || itemOverride.NativeEffects == null)
				{
					list.Add("Invalid or duplicate supported-item override: " + itemOverride.Prefab);
				}
			}
			if (list.Count == 0 && profiles != null)
			{
				foreach (ItemProfile profile in profiles)
				{
					list.AddRange(ValidateProfile(config, profile, requireDiversePools));
				}
			}
			return list;
		}

		public static List<string> ValidateProfile(GameplayConfig config, ItemProfile profile, bool requireDiversePools = false)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrWhiteSpace(profile.Category) || profile.Capabilities == null || profile.NativeEffects == null)
			{
				list.Add("Item classification is incomplete: " + profile.Prefab);
				return list;
			}
			PerkSelector perkSelector = new PerkSelector(config.Perks, config.PerkPlacementVersion);
			foreach (RarityDefinition rarity in config.Rarities)
			{
				try
				{
					if (!perkSelector.CanComplete(profile, rarity))
					{
						list.Add(profile.Prefab + " (" + profile.Category + ") cannot complete " + rarity.Name + ".");
					}
				}
				catch (InvalidOperationException ex)
				{
					list.Add(profile.Prefab + ": " + ex.Message);
					break;
				}
			}
			if (requireDiversePools)
			{
				int[] array = ((config.PerkPlacementVersion != 0) ? new int[4] { 10, 3, 4, 6 } : new int[4] { 15, 6, 6, 8 });
				int cls;
				for (cls = 0; cls < 4; cls++)
				{
					if (config.Rarities.Any((RarityDefinition r) => PerkSelector.Slots(r)[cls] > 0))
					{
						int num = config.Perks.Count((PerkDefinition p) => p.Class == (PerkClass)cls && Compatibility.Supports(p, profile, config.PerkPlacementVersion));
						if (num < array[cls])
						{
							string[] obj = new string[8]
							{
								profile.Category,
								" has ",
								num.ToString(),
								" eligible ",
								null,
								null,
								null,
								null
							};
							PerkClass perkClass = (PerkClass)cls;
							obj[4] = perkClass.ToString();
							obj[5] = " perks; requires at least ";
							obj[6] = array[cls].ToString();
							obj[7] = " for random variety.";
							list.Add(string.Concat(obj));
						}
					}
				}
			}
			return list;
		}

		private static bool Finite(double value)
		{
			if (!double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}
	}
	public sealed class DamageContribution
	{
		public string OwnerId { get; set; } = "";

		public string OriginId { get; set; } = "";

		public string SourceId { get; set; } = "base";

		public string Element { get; set; } = "damage";

		public double Amount { get; set; }

		public DamageContribution Copy(double? amount = null)
		{
			return new DamageContribution
			{
				OwnerId = OwnerId,
				OriginId = OriginId,
				SourceId = SourceId,
				Element = Element,
				Amount = (amount ?? Amount)
			};
		}
	}
	public static class DamagePartition
	{
		public static bool Finite(double v)
		{
			if (!double.IsNaN(v))
			{
				return !double.IsInfinity(v);
			}
			return false;
		}

		public static List<DamageContribution> Reconcile(IEnumerable<DamageContribution> sources, IReadOnlyDictionary<string, double> typedDamage, double actualDamage, string fallbackOwner = "", string fallbackOrigin = "")
		{
			if (!Finite(actualDamage) || actualDamage <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<DamageContribution> source = sources.Where((DamageContribution x) => Finite(x.Amount) && x.Amount > 0.0).ToList();
			List<DamageContribution> list = new List<DamageContribution>();
			foreach (KeyValuePair<string, double> pair in typedDamage.Where<KeyValuePair<string, double>>((KeyValuePair<string, double> x) => Finite(x.Value) && x.Value > 0.0))
			{
				List<DamageContribution> source2 = source.Where((DamageContribution x) => x.Element == pair.Key).ToList();
				double total = source2.Sum((DamageContribution x) => x.Amount);
				if (total <= 0.0)
				{
					list.Add(new DamageContribution
					{
						OwnerId = fallbackOwner,
						OriginId = fallbackOrigin,
						Element = pair.Key,
						Amount = pair.Value
					});
				}
				else
				{
					list.AddRange(source2.Select((DamageContribution x) => x.Copy(pair.Value * x.Amount / total)));
				}
			}
			double num = list.Sum((DamageContribution x) => x.Amount);
			if (num <= 0.0)
			{
				return new List<DamageContribution>
				{
					new DamageContribution
					{
						OwnerId = fallbackOwner,
						OriginId = fallbackOrigin,
						Amount = actualDamage
					}
				};
			}
			foreach (DamageContribution item in list)
			{
				item.Amount *= actualDamage / num;
			}
			list.OrderByDescending((DamageContribution x) => x.Amount).First().Amount += actualDamage - list.Sum((DamageContribution x) => x.Amount);
			return Merge(list);
		}

		public static List<DamageContribution> Merge(IEnumerable<DamageContribution> values)
		{
			return (from x in values
				where Finite(x.Amount) && x.Amount > 0.0
				group x by x.OwnerId + "\u001f" + x.SourceId + "\u001f" + x.Element).Select(delegate(IGrouping<string, DamageContribution> g)
			{
				DamageContribution damageContribution = g.Last().Copy();
				damageContribution.Amount = g.Sum((DamageContribution x) => x.Amount);
				return damageContribution;
			}).ToList();
		}

		public static List<DamageContribution> RoundPartition(IEnumerable<DamageContribution> values, double total)
		{
			List<DamageContribution> list = Merge(values);
			if (list.Count == 0)
			{
				return list;
			}
			long num = (long)Math.Round(Math.Max(0.0, total) * 1000.0, MidpointRounding.AwayFromZero);
			double num2 = list.Sum((DamageContribution x) => x.Amount);
			if (num2 <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<(int, double)> list2 = new List<(int, double)>();
			long num3 = 0L;
			for (int num4 = 0; num4 < list.Count; num4++)
			{
				double num5 = list[num4].Amount / num2 * (double)num;
				long num6 = (long)Math.Floor(num5);
				list[num4].Amount = (double)num6 / 1000.0;
				num3 += num6;
				list2.Add((num4, num5 - (double)num6));
			}
			foreach (var item in (from x in list2
				orderby x.fraction descending, x.index
				select x).Take((int)Math.Max(0L, num - num3)))
			{
				list[item.Item1].Amount += 0.001;
			}
			return list;
		}
	}
	public sealed class DamageLedgerSnapshot
	{
		public double WindowSeconds { get; set; }

		public double TotalDamage { get; set; }

		public double Dps => TotalDamage / WindowSeconds;

		public int HitCount { get; set; }

		public bool CapacityLimited { get; set; }

		public List<DamageContribution> Sources { get; set; } = new List<DamageContribution>();
	}
	public sealed class DamageLedger
	{
		private sealed class Entry
		{
			internal double Time;

			internal double Actual;

			internal string Id = "";

			internal List<DamageContribution> Parts = new List<DamageContribution>();
		}

		public const int MaximumEventSources = 256;

		private readonly LinkedList<Entry> entries = new LinkedList<Entry>();

		private readonly Dictionary<string, double> ids = new Dictionary<string, double>(StringComparer.Ordinal);

		private readonly Queue<(string id, double time)> idOrder = new Queue<(string, double)>();

		private readonly object gate = new object();

		private readonly int capacity;

		private readonly double retention;

		private double lastEviction = double.NegativeInfinity;

		public int RetainedEvents
		{
			get
			{
				lock (gate)
				{
					return entries.Count;
				}
			}
		}

		public int RetainedIds
		{
			get
			{
				lock (gate)
				{
					return ids.Count;
				}
			}
		}

		public DamageLedger(int capacity = 60000, double retentionSeconds = 1800.0)
		{
			if (capacity < 1 || retentionSeconds < 1.0)
			{
				throw new ArgumentOutOfRangeException();
			}
			this.capacity = capacity;
			retention = retentionSeconds;
		}

		public bool Add(string id, double now, double actual, IEnumerable<DamageContribution> contributions)
		{
			if (string.IsNullOrWhiteSpace(id) || !DamagePartition.Finite(now) || !DamagePartition.Finite(actual) || actual <= 0.0)
			{
				return false;
			}
			lock (gate)
			{
				Prune(now);
				if (ids.ContainsKey(id))
				{
					return false;
				}
				List<DamageContribution> list = DamagePartition.Merge(contributions);
				double num = list.Sum((DamageContribution x) => x.Amount);
				if (list.Count == 0 || list.Count > 256 || !DamagePartition.Finite(num) || num <= 0.0)
				{
					return false;
				}
				foreach (DamageContribution item in list)
				{
					item.Amount *= actual / num;
				}
				ids[id] = now;
				idOrder.Enqueue((id, now));
				entries.AddLast(new Entry
				{
					Id = id,
					Time = now,
					Actual = actual,
					Parts = list
				});
				while (entries.Count > capacity)
				{
					lastEviction = entries.First.Value.Time;
					entries.RemoveFirst();
				}
				while (ids.Count > capacity * 2)
				{
					(string, double) tuple = idOrder.Dequeue();
					ids.Remove(tuple.Item1);
				}
				return true;
			}
		}

		private void Prune(double now)
		{
			while (entries.First != null && entries.First.Value.Time <= now - retention)
			{
				entries.RemoveFirst();
			}
			while (idOrder.Count > 0 && idOrder.Peek().time <= now - retention)
			{
				(string, double) tuple = idOrder.Dequeue();
				ids.Remove(tuple.Item1);
			}
		}

		public DamageLedgerSnapshot Snapshot(double now, double windowSeconds)
		{
			if (!DamagePartition.Finite(now) || !DamagePartition.Finite(windowSeconds) || windowSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException();
			}
			lock (gate)
			{
				Prune(now);
				windowSeconds = Math.Min(retention, windowSeconds);
				List<Entry> list = entries.Where((Entry x) => x.Time > now - windowSeconds && x.Time <= now).ToList();
				return new DamageLedgerSnapshot
				{
					WindowSeconds = windowSeconds,
					TotalDamage = list.Sum((Entry x) => x.Actual),
					HitCount = list.Count,
					CapacityLimited = (lastEviction > now - windowSeconds),
					Sources = DamagePartition.Merge(list.SelectMany((Entry x) => x.Parts))
				};
			}
		}

		public void Clear()
		{
			lock (gate)
			{
				entries.Clear();
				ids.Clear();
				idOrder.Clear();
				lastEviction = double.NegativeInfinity;
			}
		}
	}
	public sealed class DamageOverTimePool
	{
		private sealed class Bucket
		{
			internal List<DamageContribution> Remaining = new List<DamageContribution>();

			internal List<DamageContribution> LastWeights = new List<DamageContribution>();
		}

		public const int MaximumSources = 1024;

		private readonly Dictionary<string, Bucket> buckets = new Dictionary<string, Bucket>(StringComparer.Ordinal);

		private Bucket Get(string element)
		{
			if (!buckets.TryGetValue(element, out Bucket value))
			{
				value = (buckets[element] = new Bucket());
			}
			return value;
		}

		public void Add(string element, double nativeBefore, double nativeAfter, IEnumerable<DamageContribution> incoming)
		{
			Bucket bucket = Get(element);
			Sync(bucket, element, Math.Max(0.0, nativeBefore));
			double num = Math.Max(0.0, nativeAfter - nativeBefore);
			if (num > 0.0)
			{
				bucket.Remaining = Bound(DamagePartition.Merge(bucket.Remaining.Concat(Scale(incoming, element, num))), element);
			}
			bucket.LastWeights = bucket.Remaining.Select((DamageContribution x) => x.Copy()).ToList();
		}

		public void Replace(string element, double nativeBefore, double attempted, double nativeAfter, IEnumerable<DamageContribution> incoming)
		{
			Bucket bucket = Get(element);
			Sync(bucket, element, Math.Max(0.0, nativeBefore));
			if (attempted >= nativeBefore)
			{
				bucket.Remaining = Bound(Scale(incoming, element, Math.Max(0.0, nativeAfter)), element);
				bucket.LastWeights = bucket.Remaining.Select((DamageContribution x) => x.Copy()).ToList();
			}
		}

		public List<DamageContribution> Take(string element, double tickDamage)
		{
			if (tickDamage <= 0.0)
			{
				return new List<DamageContribution>();
			}
			Bucket bucket = Get(element);
			List<DamageContribution> result = Scale((bucket.Remaining.Count > 0) ? bucket.Remaining : bucket.LastWeights, element, tickDamage);
			double num = bucket.Remaining.Sum((DamageContribution x) => x.Amount);
			if (num > 0.0)
			{
				bucket.Remaining = Scale(bucket.Remaining, element, Math.Max(0.0, num - tickDamage));
			}
			return result;
		}

		private static List<DamageContribution> Scale(IEnumerable<DamageContribution> source, string element, double amount)
		{
			if (amount <= 0.0)
			{
				return new List<DamageContribution>();
			}
			List<DamageContribution> list = DamagePartition.Merge(source.Where((DamageContribution x) => x.Element == element));
			double num = list.Sum((DamageContribution x) => x.Amount);
			if (num <= 0.0)
			{
				return new List<DamageContribution>
				{
					new DamageContribution
					{
						Element = element,
						Amount = amount
					}
				};
			}
			foreach (DamageContribution item in list)
			{
				item.Amount *= amount / num;
			}
			return list;
		}

		private static List<DamageContribution> Bound(List<DamageContribution> rows, string element)
		{
			if (rows.Count <= 1024)
			{
				return rows;
			}
			List<DamageContribution> list = rows.OrderByDescending((DamageContribution x) => x.Amount).Take(1023).ToList();
			list.Add(new DamageContribution
			{
				Element = element,
				Amount = rows.Sum((DamageContribution x) => x.Amount) - list.Sum((DamageContribution x) => x.Amount)
			});
			return list;
		}

		private static void Sync(Bucket b, string element, double native)
		{
			double num = b.Remaining.Sum((DamageContribution x) => x.Amount);
			if (num > native)
			{
				b.Remaining = Scale(b.Remaining, element, native);
			}
			else if (native > num)
			{
				b.Remaining.Add(new DamageContribution
				{
					Element = element,
					Amount = native - num
				});
			}
		}
	}
	public static class Defaults
	{
		public const string Version = "0.5.4";

		public static List<RarityDefinition> Rarities()
		{
			return new List<RarityDefinition>
			{
				R("worthless", "Worthless", -6, 30, "#60646C"),
				R("ruined", "Ruined", -5, 70, "#746357"),
				R("broken", "Broken", -4, 150, "#8D5550"),
				R("damaged", "Damaged", -3, 250, "#AA725C"),
				R("worn", "Worn", -2, 300, "#A8977C"),
				R("inferior", "Inferior", -1, 400, "#B6B0A3"),
				R("default", "Default", 0, 3500, "#B9B9B9"),
				R("common", "Common", 1, 2500, "#E0E0E0"),
				R("uncommon", "Uncommon", 2, 1500, "#63C76A"),
				R("rare", "Rare", 3, 660, "#4B92F1"),
				R("very_rare", "Very Rare", 4, 300, "#50CFD8"),
				R("exceptional", "Exceptional", 5, 150, "#6B63E8"),
				R("epic", "Epic", 6, 75, "#AB62EB", 5, 1),
				R("heroic", "Heroic", 7, 40, "#DF69B2", 6, 1),
				R("legendary", "Legendary", 8, 20, "#F49B3D", 6, 2),
				R("mythic", "Mythic", 9, 18, "#F05B68", 6, 2, 1),
				R("exalted", "Exalted", 10, 15, "#DDB52F", 6, 2, 2),
				R("divine", "Divine", 11, 12, "#FFE48A", 7, 2, 2),
				R("transcendent", "Transcendent", 12, 10, "#BEF6FF", 7, 2, 3)
			};
		}

		private static RarityDefinition R(string id, string name, int rank, int weight, string color, int standard = 0, int special = 0, int ultra = 0)
		{
			return new RarityDefinition
			{
				Id = id,
				Name = name,
				Rank = rank,
				Weight = weight,
				Color = color,
				NegativeSlots = ((rank < 0) ? (-rank) : 0),
				StandardSlots = ((rank >= 0) ? ((standard == 0) ? rank : standard) : 0),
				SpecialSlots = special,
				UltraSlots = ultra
			};
		}

		public static List<StrengthBand> StrengthBands()
		{
			return new List<StrengthBand>
			{
				new StrengthBand
				{
					MinScore = 0,
					MaxScore = 999,
					Weight = 8000
				},
				new StrengthBand
				{
					MinScore = 1000,
					MaxScore = 2499,
					Weight = 1400
				},
				new StrengthBand
				{
					MinScore = 2500,
					MaxScore = 4999,
					Weight = 450
				},
				new StrengthBand
				{
					MinScore = 5000,
					MaxScore = 7999,
					Weight = 120
				},
				new StrengthBand
				{
					MinScore = 8000,
					MaxScore = 9499,
					Weight = 28
				},
				new StrengthBand
				{
					MinScore = 9500,
					MaxScore = 10000,
					Weight = 2
				}
			};
		}
	}
	public static class EffectiveRange
	{
		public static PerkParameter ForRank(PerkParameter parameter, int rank)
		{
			if (parameter == null)
			{
				throw new ArgumentNullException("parameter");
			}
			double value;
			double max = ((parameter.HighRankMaxima != null && parameter.HighRankMaxima.TryGetValue(rank, out value)) ? value : parameter.Max);
			return new PerkParameter
			{
				Id = parameter.Id,
				Min = parameter.Min,
				Max = max,
				Unit = parameter.Unit,
				Precision = parameter.Precision,
				HigherIsBetter = parameter.HigherIsBetter,
				HighRankMaxima = new Dictionary<int, double>()
			};
		}
	}
	public static class Expansion045
	{
		public const int AddedCount = 47;

		public const int CatalogueCount = 248;

		private static readonly Lazy<IReadOnlyDictionary<string, ExpansionPerk>> Metadata = new Lazy<IReadOnlyDictionary<string, ExpansionPerk>>(() => Create().ToDictionary<ExpansionPerk, string>((ExpansionPerk p) => p.Definition.Id, StringComparer.Ordinal));

		public static IReadOnlyDictionary<string, ExpansionPerk> Details => Metadata.Value;

		public static List<ExpansionPerk> Create()
		{
			List<ExpansionPerk> list = MeleeExpansion045.Create();
			list.AddRange(RangedExpansion045.Create());
			list.AddRange(GuardExpansion045.Create());
			if (list.Count != 47 || list.Select((ExpansionPerk p) => p.Definition.Id).Distinct<string>(StringComparer.Ordinal).Count() != 47)
			{
				throw new InvalidOperationException("The 0.4.5 expansion must contain exactly 47 distinct mechanics.");
			}
			return list;
		}

		public static void Add(List<PerkDefinition> definitions)
		{
			definitions.AddRange(from p in Create()
				select p.Definition);
		}
	}
	public sealed class ExpansionPerk
	{
		public PerkDefinition Definition { get; set; } = new PerkDefinition();

		public string Compact { get; set; } = "";

		public string When { get; set; } = "";

		public string Example { get; set; } = "";

		public string Notes { get; set; } = "";

		public string GuideMode { get; set; } = "";

		public string GuideCategory { get; set; } = "combat";

		public string ScoreTarget { get; set; } = "";

		public string ScoreMode { get; set; } = "";

		public string ScoreFamily { get; set; } = "";

		public double ScoreWeight { get; set; } = 1.0;

		public double ScoreUptime { get; set; } = 1.0;

		public double ScoreCap { get; set; } = 100000.0;

		public double ScoreEventSeconds { get; set; }

		public double ScoreEvery { get; set; } = 1.0;

		public double ScoreDuration { get; set; }

		public bool ScoreLocal { get; set; } = true;
	}
	public sealed class FateGenerator
	{
		private readonly GameplayConfig config;

		private readonly IRandomSource rarityRandom;

		private readonly IRandomSource selectionRandom;

		private readonly IRandomSource cosmeticRandom;

		private readonly StrengthSampler strength;

		private readonly PerkSelector selector;

		private readonly QualityProbability qualityProbability;

		private readonly string configurationFingerprint;

		private readonly Dictionary<string, Dictionary<string, double>?> inclusionCache = new Dictionary<string, Dictionary<string, double>>(StringComparer.Ordinal);

		private readonly Dictionary<string, List<string>> validationCache = new Dictionary<string, List<string>>(StringComparer.Ordinal);

		private readonly object gate = new object();

		public FateGenerator(GameplayConfig config, IRandomSource? rarityRng = null, IRandomSource? selectionRng = null, IRandomSource? strengthRng = null, IRandomSource? cosmeticRng = null)
		{
			List<string> list = ConfigurationValidator.Validate(config);
			if (list.Count != 0)
			{
				throw new ArgumentException(string.Join("\n", list));
			}
			this.config = JsonConvert.DeserializeObject<GameplayConfig>(JsonConvert.SerializeO