using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Bloodstone.API;
using Bloodstone.Hooks;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using JewelForge.Configs;
using JewelForge.Database;
using JewelForge.Inventory;
using JewelForge.Utils;
using Microsoft.CodeAnalysis;
using ProjectM;
using ProjectM.Network;
using Stunlock.Core;
using Unity.Collections;
using Unity.Entities;
using Unity.Mathematics;
using UnityEngine;
using VampireCommandFramework;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("JewelForge")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Creates a perfect jewel for a cost.")]
[assembly: AssemblyFileVersion("0.1.10.0")]
[assembly: AssemblyInformationalVersion("0.1.10+1.Branch.main.Sha.c33d0879382e1a0da34861ec55914ba7e637a80e")]
[assembly: AssemblyProduct("JewelForge")]
[assembly: AssemblyTitle("JewelForge")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.10.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace JewelForge
{
	[BepInPlugin("JewelForge", "JewelForge", "0.1.10")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[Reloadable]
	public class Plugin : BasePlugin
	{
		private Harmony? _harmony;

		public static ManualLogSource? Logger;

		private static bool _forgeSchedulerFound;

		private static MethodInfo? _shouldEnableMethod;

		public override void Load()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			if (Helper.IsServer)
			{
				Logger = ((BasePlugin)this).Log;
				ManualLogSource log = ((BasePlugin)this).Log;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("JewelForge");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] v");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("0.1.10");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" loading...");
				}
				log.LogInfo(val);
				MainConfig.SettingsInit();
				DB.inits();
				CommandRegistry.RegisterAll();
				_harmony = new Harmony("JewelForge");
				_harmony.PatchAll(Assembly.GetExecutingAssembly());
				TryDetectForgeScheduler();
				GameFrame.Initialize();
				GameFrame.OnUpdate += new GameFrameUpdateEventHandler(OnFrameUpdate);
				ManualLogSource log2 = ((BasePlugin)this).Log;
				val = new BepInExInfoLogInterpolatedStringHandler(28, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("JewelForge");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] initialized successfully.");
				}
				log2.LogInfo(val);
			}
			else
			{
				((BasePlugin)this).Log.LogFatal((object)"No Server world found. Did you install a server mod on the client?");
			}
		}

		public override bool Unload()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			CommandRegistry.UnregisterAssembly();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			GameFrame.OnUpdate -= new GameFrameUpdateEventHandler(OnFrameUpdate);
			GameFrame.Uninitialize();
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(12, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("JewelForge");
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] unloaded.");
			}
			log.LogInfo(val);
			return true;
		}

		private void OnFrameUpdate()
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			if (!_forgeSchedulerFound || _shouldEnableMethod == null)
			{
				return;
			}
			try
			{
				object obj = _shouldEnableMethod.Invoke(null, null);
				if (!(obj is bool))
				{
					return;
				}
				bool flag = (bool)obj;
				if (1 == 0)
				{
					return;
				}
				if (!flag && DB.EnabledCommand)
				{
					DB.EnabledCommand = false;
					ManualLogSource? logger = Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[JewelForge] Disabled by day-based automation.");
					}
				}
				else if (flag && !DB.EnabledCommand)
				{
					DB.EnabledCommand = true;
					ManualLogSource? logger2 = Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)"[JewelForge] Enabled by day-based automation.");
					}
					BroadcastMessage("<color=#FFCC00>[JewelForge]</color> <color=white>The JewelForge is now open!</color>");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = Logger;
				if (logger3 != null)
				{
					bool flag2 = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(45, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[JewelForge] Error calling ForgeScheduler => ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					logger3.LogWarning(val);
				}
			}
		}

		private void TryDetectForgeScheduler()
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "ForgeScheduler");
				if (assembly == null)
				{
					ManualLogSource? logger = Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[JewelForge] ForgeScheduler not found => no day-based override.");
					}
					return;
				}
				Type type = assembly.GetType("ForgeScheduler.JewelForgeScheduleManager");
				if (type == null)
				{
					ManualLogSource? logger2 = Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)"[JewelForge] Found 'ForgeScheduler' assembly but not 'JewelForgeScheduleManager' => ignoring override.");
					}
					return;
				}
				_shouldEnableMethod = type.GetMethod("ShouldEnableJewelForge", BindingFlags.Static | BindingFlags.Public);
				if (_shouldEnableMethod != null)
				{
					_forgeSchedulerFound = true;
					ManualLogSource? logger3 = Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"[JewelForge] Detected JewelForgeScheduleManager => day-based override active!");
					}
				}
				else
				{
					ManualLogSource? logger4 = Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)"[JewelForge] JewelForgeScheduleManager found but no 'ShouldEnableJewelForge()' => ignoring override.");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger5 = Logger;
				if (logger5 != null)
				{
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(47, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[JewelForge] Error detecting ForgeScheduler => ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					logger5.LogWarning(val);
				}
			}
		}

		private void BroadcastMessage(string text)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			EntityQuery val = ((EntityManager)(ref entityManager)).CreateEntityQuery((ComponentType[])(object)new ComponentType[1] { ComponentType.ReadOnly<User>() });
			NativeArray<Entity> val2 = ((EntityQuery)(ref val)).ToEntityArray(AllocatorHandle.op_Implicit((Allocator)2));
			Enumerator<Entity> enumerator = val2.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entity current = enumerator.Current;
				if (((EntityManager)(ref entityManager)).HasComponent<User>(current))
				{
					User componentData = ((EntityManager)(ref entityManager)).GetComponentData<User>(current);
					ServerChatUtils.SendSystemMessageToClient(entityManager, componentData, text);
				}
			}
			val2.Dispose();
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "JewelForge";

		public const string PLUGIN_NAME = "JewelForge";

		public const string PLUGIN_VERSION = "0.1.10";
	}
}
namespace JewelForge.Configs
{
	internal class MainConfig
	{
		private static readonly string FileDirectory = Path.Combine("BepInEx", "config");

		private static readonly string FileName = "JewelForge.cfg";

		private static readonly string FullPath = Path.Combine(FileDirectory, FileName);

		private static readonly ConfigFile Conf = new ConfigFile(FullPath, true);

		public static ConfigEntry<bool>? EnableCommand;

		public static ConfigEntry<bool>? AdminOnlyCommand;

		public static ConfigEntry<int>? TierLevel;

		public static ConfigEntry<float>? SkillModPower;

		public static ConfigEntry<int>? RequiredItemGUID;

		public static ConfigEntry<int>? RequiredItemAmount;

		public static ConfigEntry<string>? ItemName;

		public static void SettingsInit()
		{
			EnableCommand = Conf.Bind<bool>("JewelForge", "Enabled", true, "Enable the 'JewelForge' command.");
			AdminOnlyCommand = Conf.Bind<bool>("JewelForge", "AdminOnly", false, "Restrict the 'JewelForge' command to admins only.");
			RequiredItemGUID = Conf.Bind<int>("JewelForge", "RequiredItemGUID", -598100816, "PrefabGUID of the item required for the JewelForge command.");
			RequiredItemAmount = Conf.Bind<int>("JewelForge", "RequiredItemAmount", 1000, "Number of required items for the JewelForge command.");
			ItemName = Conf.Bind<string>("JewelForge", "ItemName", "Thistle", "Name of the item required for the JewelForge command.");
			SettingsBind();
		}

		public static void SettingsBind()
		{
			if (TierLevel != null)
			{
				TierLevel.Value = 4;
			}
			if (SkillModPower != null)
			{
				SkillModPower.Value = 1f;
			}
			DB.AdminOnlyCommand = AdminOnlyCommand?.Value ?? false;
			DB.EnabledCommand = EnableCommand?.Value ?? true;
			DB.JewelTier = (TierLevel?.Value ?? 4) - 1;
			DB.SkillPower = SkillModPower?.Value ?? 1f;
			DB.RequiredItemGUID = RequiredItemGUID?.Value ?? (-598100816);
			DB.RequiredItemAmount = RequiredItemAmount?.Value ?? 5;
			DB.ItemName = ItemName?.Value ?? "Unknown Item";
		}

		public static void Reload()
		{
			Conf.Reload();
			Conf.Save();
			SettingsBind();
		}
	}
}
namespace JewelForge.Inventory
{
	internal static class JewelForgeInventorySystem
	{
		public static bool HasEnoughOfItem(Entity playerEntity, PrefabGUID itemGuid, int neededAmount)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			EntityManager entityManager = VWorld.Server.EntityManager;
			Entity val = default(Entity);
			if (!InventoryUtilities.TryGetInventoryEntity(entityManager, playerEntity, ref val, 0))
			{
				return false;
			}
			if (!((EntityManager)(ref entityManager)).HasComponent<InventoryBuffer>(val))
			{
				return false;
			}
			DynamicBuffer<InventoryBuffer> buffer = ((EntityManager)(ref entityManager)).GetBuffer<InventoryBuffer>(val, false);
			int num = 0;
			Enumerator<InventoryBuffer> enumerator = buffer.GetEnumerator();
			while (enumerator.MoveNext())
			{
				InventoryBuffer current = enumerator.Current;
				if (current.ItemType == itemGuid)
				{
					num += current.Amount;
					if (num >= neededAmount)
					{
						return true;
					}
				}
			}
			return num >= neededAmount;
		}

		public static bool TryRemoveItem(Entity playerEntity, PrefabGUID itemGuid, int removeAmount)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (removeAmount <= 0)
			{
				return true;
			}
			EntityManager entityManager = VWorld.Server.EntityManager;
			Entity val = default(Entity);
			if (!InventoryUtilities.TryGetInventoryEntity(entityManager, playerEntity, ref val, 0))
			{
				return false;
			}
			if (!((EntityManager)(ref entityManager)).HasComponent<InventoryBuffer>(val))
			{
				return false;
			}
			DynamicBuffer<InventoryBuffer> buffer = ((EntityManager)(ref entityManager)).GetBuffer<InventoryBuffer>(val, false);
			int num = removeAmount;
			for (int i = 0; i < buffer.Length; i++)
			{
				if (num <= 0)
				{
					break;
				}
				InventoryBuffer val2 = buffer[i];
				if (val2.ItemType == itemGuid && val2.Amount > 0)
				{
					int num2 = math.min(val2.Amount, num);
					InventoryUtilitiesServer.TryRemoveItemAtIndex(entityManager, playerEntity, val2.ItemType, num2, i, false);
					num -= num2;
				}
			}
			return num <= 0;
		}
	}
}
namespace JewelForge.Commands
{
	internal class JewelForgeCommands
	{
		private static readonly Dictionary<string, string> skillSynonyms = new Dictionary<string, string> { { "lightningcurtain", "lightningwall" } };

		[Command("j", "j", ".j ?", "Create or query a jewel (or list by school).", null, false)]
		public static void JewelForgeCommand(ChatCommandContext ctx, string arg1 = "", string arg2 = "")
		{
			string userSkillName = arg1;
			if (skillSynonyms.TryGetValue(arg1.ToLower(), out var value))
			{
				arg1 = value;
			}
			if (!DB.EnabledCommand)
			{
				ctx.Reply("<color=red> This command is currently disabled.</color>");
			}
			else if (arg1.Equals("school", StringComparison.OrdinalIgnoreCase))
			{
				HandleSchoolCommand(ctx, arg2);
			}
			else if (string.IsNullOrEmpty(arg1) || arg1 == "?")
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine(" [Skill Name] [Skill Modifiers]");
				stringBuilder.AppendLine("Example: .j bloodrage 1234.");
				stringBuilder.AppendLine("Use '.j [Skill Name] ?' to list available modifiers for that skill.");
				stringBuilder.AppendLine("Use '.j school [blood/chaos/etc.]' to list spells in a school.");
				ctx.Reply(stringBuilder.ToString());
			}
			else if (arg2 == "?")
			{
				HandleSkillModifiersQuery(ctx, arg1, userSkillName);
			}
			else
			{
				HandleJewelCreation(ctx, arg1, arg2, userSkillName);
			}
		}

		[Command("jewelreload", null, null, "Reloads the JewelForge config file.", null, true)]
		public static void ReloadJewelForgeConfig(ChatCommandContext ctx)
		{
			try
			{
				MainConfig.Reload();
				ctx.Reply("<color=green>[JewelForge]</color> Config reloaded successfully!");
			}
			catch (Exception ex)
			{
				ctx.Reply("<color=red>[JewelForge]</color> Failed to reload config: " + ex.Message);
			}
		}

		private static void HandleSchoolCommand(ChatCommandContext ctx, string categoryName)
		{
			StringBuilder stringBuilder2;
			StringBuilder.AppendInterpolatedStringHandler handler;
			if (string.IsNullOrEmpty(categoryName) || categoryName == "?")
			{
				List<string> list = DB.SkillClass.Keys.ToList();
				list.Sort();
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("<color=yellow> Available schools:</color>");
				for (int i = 0; i < list.Count; i++)
				{
					string text = list[i];
					string colorForSkill = DB.GetColorForSkill(text);
					string value = Capitalize(text);
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder3 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(39, 3, stringBuilder2);
					handler.AppendLiteral("<color=white>");
					handler.AppendFormatted(i + 1);
					handler.AppendLiteral(".</color> <color=");
					handler.AppendFormatted(colorForSkill);
					handler.AppendLiteral(">");
					handler.AppendFormatted(value);
					handler.AppendLiteral("</color>");
					stringBuilder3.AppendLine(ref handler);
				}
				ctx.Reply(stringBuilder.ToString());
				return;
			}
			if (!DB.SkillClass.ContainsKey(categoryName.ToLower()))
			{
				ctx.Reply("<color=red> Unknown school '" + categoryName + "'</color>");
				return;
			}
			List<string> list2 = DB.SkillClass[categoryName.ToLower()];
			string colorForSkill2 = DB.GetColorForSkill(categoryName.ToLower());
			string value2 = Capitalize(categoryName);
			StringBuilder stringBuilder4 = new StringBuilder();
			stringBuilder2 = stringBuilder4;
			StringBuilder stringBuilder5 = stringBuilder2;
			handler = new StringBuilder.AppendInterpolatedStringHandler(37, 2, stringBuilder2);
			handler.AppendLiteral("<color=");
			handler.AppendFormatted(colorForSkill2);
			handler.AppendLiteral("> Spells in '");
			handler.AppendFormatted(value2);
			handler.AppendLiteral("' school:</color>");
			stringBuilder5.AppendLine(ref handler);
			for (int j = 0; j < list2.Count; j++)
			{
				string input = list2[j];
				stringBuilder2 = stringBuilder4;
				StringBuilder stringBuilder6 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(39, 3, stringBuilder2);
				handler.AppendLiteral("<color=white>");
				handler.AppendFormatted(j + 1);
				handler.AppendLiteral(".</color> <color=");
				handler.AppendFormatted(colorForSkill2);
				handler.AppendLiteral(">");
				handler.AppendFormatted(Capitalize(input));
				handler.AppendLiteral("</color>");
				stringBuilder6.AppendLine(ref handler);
			}
			ctx.Reply(stringBuilder4.ToString());
		}

		private static void HandleSkillModifiersQuery(ChatCommandContext ctx, string realSkillName, string userSkillName)
		{
			if (!DB.SkillModList.TryGetValue(realSkillName.ToLower(), out var value))
			{
				ctx.Reply("<color=red> Skill '" + userSkillName + "' not found.</color>");
				return;
			}
			string colorForSkill = DB.GetColorForSkill(realSkillName.ToLower());
			string value2 = Capitalize(userSkillName);
			List<string> list = new List<string> { $"<color={colorForSkill}> Modifiers for skill '{value2}':</color>" };
			List<KeyValuePair<string, CreateJevelLegendStruct>> list2 = value.OrderBy((KeyValuePair<string, CreateJevelLegendStruct> k) => int.Parse(k.Key)).ToList();
			foreach (KeyValuePair<string, CreateJevelLegendStruct> item in list2)
			{
				string key = item.Key;
				string description = item.Value.Description;
				list.Add($"<color={colorForSkill}>{key}.</color> <color=white>{description}</color>");
			}
			SendMultiLineSafeReply(ctx, list, 460);
		}

		private static void HandleJewelCreation(ChatCommandContext ctx, string realSkillName, string modsArg, string userSkillName)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			if (!DB.SkillModList.TryGetValue(realSkillName.ToLower(), out var value))
			{
				ctx.Reply("<color=red> Skill '" + userSkillName + "' not found.</color>");
				return;
			}
			if (modsArg.Length != 4)
			{
				ctx.Reply("<color=red> You must provide exactly 4 modifiers.</color>");
				return;
			}
			string[] array = new string[4];
			for (int i = 0; i < 4; i++)
			{
				string text = modsArg[i].ToString();
				if (!value.ContainsKey(text))
				{
					ctx.Reply($"<color=red> Modifier '{text}' is invalid for skill '{userSkillName}'.</color>");
					return;
				}
				array[i] = text;
			}
			if (HasDuplicateModifiers(array))
			{
				ctx.Reply("<color=red> Modifiers cannot be duplicated.</color>");
				return;
			}
			PrefabGUID itemGuid = default(PrefabGUID);
			((PrefabGUID)(ref itemGuid))..ctor(DB.RequiredItemGUID);
			int requiredItemAmount = DB.RequiredItemAmount;
			string value2 = MainConfig.ItemName?.Value ?? "Unknown Item";
			Entity senderCharacterEntity = ctx.Event.SenderCharacterEntity;
			if (!JewelForgeInventorySystem.HasEnoughOfItem(senderCharacterEntity, itemGuid, requiredItemAmount))
			{
				ctx.Reply($"<color=red> The forge requires {requiredItemAmount} {value2} to create a jewel.</color>");
			}
			else if (!JewelForgeInventorySystem.TryRemoveItem(senderCharacterEntity, itemGuid, requiredItemAmount))
			{
				ctx.Reply("<color=red> Failed to remove the required items from your inventory.</color>");
			}
			else
			{
				string colorForSkill = DB.GetColorForSkill(realSkillName.ToLower());
				string value3 = Capitalize(userSkillName);
				ctx.Reply($"<color=green> Payment successful.</color> <color=white>Creating your <color={colorForSkill}>{value3}</color> jewel...</color>");
				Helper.CreateJewel(ctx.Event.User, realSkillName.ToLower(), array, value);
			}
		}

		private static bool HasDuplicateModifiers(string[] mods)
		{
			for (int i = 0; i < mods.Length; i++)
			{
				for (int j = i + 1; j < mods.Length; j++)
				{
					if (mods[i] == mods[j])
					{
						return true;
					}
				}
			}
			return false;
		}

		private static string Capitalize(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}
			return char.ToUpper(input[0]) + input.Substring(1).ToLower();
		}

		private static void SendMultiLineSafeReply(ChatCommandContext ctx, IEnumerable<string> lines, int maxLength)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string line in lines)
			{
				if (stringBuilder.Length + line.Length + 1 > maxLength)
				{
					ctx.Reply(stringBuilder.ToString().TrimEnd());
					stringBuilder.Clear();
				}
				stringBuilder.AppendLine(line);
			}
			if (stringBuilder.Length > 0)
			{
				ctx.Reply(stringBuilder.ToString().TrimEnd());
			}
		}
	}
}
namespace JewelForge.Utils
{
	internal static class Helper
	{
		private static World? _serverWorld;

		private static PrefabCollectionSystem PrefabCollectionSystem => Server.GetExistingSystemManaged<PrefabCollectionSystem>();

		private static Dictionary<string, PrefabGUID> NameToPrefab => PrefabCollectionSystem.NameToPrefabGuidDictionary;

		public static World Server
		{
			get
			{
				if (_serverWorld != null)
				{
					return _serverWorld;
				}
				_serverWorld = GetWorld("Server") ?? throw new Exception("Server world not found. Did you install a server mod?");
				return _serverWorld;
			}
		}

		public static bool IsServer => Application.productName == "VRisingServer";

		public static void CreateJewel(User user, string ability, string[] mods, ConcurrentDictionary<string, CreateJevelLegendStruct> modList)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			PrefabGUID[] array = (PrefabGUID[])(object)new PrefabGUID[mods.Length];
			float[] array2 = new float[mods.Length];
			for (int i = 0; i < mods.Length; i++)
			{
				if (mods[i] != "0" && modList.TryGetValue(mods[i], out var value))
				{
					array[i] = NameToPrefab[value.Mod];
					array2[i] = value.Power;
				}
				else
				{
					array[i] = new PrefabGUID(0);
					array2[i] = 0f;
				}
			}
			CreateJewelDebugEventV2 val = default(CreateJewelDebugEventV2);
			val.AbilityPrefabGuid = NameToPrefab[DB.abilityNames[ability]];
			val.Equip = false;
			val.SpellMod1 = array[0];
			val.SpellMod1Power = array2[0];
			val.SpellMod2 = array[1];
			val.SpellMod2Power = array2[1];
			val.SpellMod3 = array[2];
			val.SpellMod3Power = array2[2];
			val.SpellMod4 = array[3];
			val.SpellMod4Power = array2[3];
			val.Tier = DB.JewelTier;
			CreateJewelDebugEventV2 val2 = val;
			Server.GetExistingSystemManaged<DebugEventsSystem>().CreateJewelEvent(user.Index, ref val2);
		}

		private static World GetWorld(string name)
		{
			Enumerator<World> enumerator = World.s_AllWorlds.GetEnumerator();
			while (enumerator.MoveNext())
			{
				World current = enumerator.Current;
				if (current.Name == name)
				{
					return current;
				}
			}
			throw new Exception("World '" + name + "' not found.");
		}
	}
}
namespace JewelForge.Database
{
	internal class DB
	{
		public static float SkillPower = 0f;

		public static int JewelTier = 0;

		public static bool EnabledCommand = true;

		public static bool AdminOnlyCommand = false;

		public static ConcurrentDictionary<string, ConcurrentDictionary<string, CreateJevelLegendStruct>> SkillModList = new ConcurrentDictionary<string, ConcurrentDictionary<string, CreateJevelLegendStruct>>();

		public static ImmutableDictionary<string, List<string>> SkillClass = ImmutableDictionary.Create<string, List<string>>().Add("blood", new List<string> { "bloodfountain", "bloodrage", "bloodrite", "sanguinecoil", "shadowbolt", "veilofblood" }).Add("chaos", new List<string> { "aftershock", "chaosbarrier", "powersurge", "void", "volley", "veilofchaos" })
			.Add("frost", new List<string> { "coldsnap", "crystallance", "frostbarrier", "frostbat", "icenova", "veiloffrost" })
			.Add("illusion", new List<string> { "misttrance", "mosquito", "phantomaegis", "spectralwolf", "wraithspear", "veilofillusion" })
			.Add("storm", new List<string> { "balllightning", "cyclone", "discharge", "lightningwall", "polarityshift", "veilofstorm" })
			.Add("unholy", new List<string> { "corpseexplosion", "corruptedskull", "deathknight", "soulburn", "wardofthedamned", "veilofbones" });

		public static ImmutableDictionary<string, string> abilityNames = ImmutableDictionary.Create<string, string>().Add("bloodfountain", "AB_Blood_BloodFountain_AbilityGroup").Add("bloodrage", "AB_Blood_BloodRage_AbilityGroup")
			.Add("bloodrite", "AB_Blood_BloodRite_AbilityGroup")
			.Add("sanguinecoil", "AB_Blood_SanguineCoil_AbilityGroup")
			.Add("shadowbolt", "AB_Blood_Shadowbolt_AbilityGroup")
			.Add("veilofblood", "AB_Vampire_VeilOfBlood_Group")
			.Add("aftershock", "AB_Chaos_Aftershock_Group")
			.Add("chaosbarrier", "AB_Chaos_Barrier_AbilityGroup")
			.Add("powersurge", "AB_Chaos_PowerSurge_AbilityGroup")
			.Add("void", "AB_Chaos_Void_AbilityGroup")
			.Add("volley", "AB_Chaos_Volley_AbilityGroup")
			.Add("veilofchaos", "AB_Vampire_VeilOfChaos_Group")
			.Add("coldsnap", "AB_Frost_ColdSnap_AbilityGroup")
			.Add("crystallance", "AB_Frost_CrystalLance_AbilityGroup")
			.Add("frostbarrier", "AB_FrostBarrier_AbilityGroup")
			.Add("frostbat", "AB_Frost_FrostBat_AbilityGroup")
			.Add("icenova", "AB_Frost_IceNova_AbilityGroup")
			.Add("veiloffrost", "AB_Vampire_VeilOfFrost_Group")
			.Add("misttrance", "AB_Illusion_MistTrance_AbilityGroup")
			.Add("mosquito", "AB_Illusion_Mosquito_AbilityGroup")
			.Add("phantomaegis", "AB_Illusion_PhantomAegis_AbilityGroup")
			.Add("spectralwolf", "AB_Illusion_SpectralWolf_AbilityGroup")
			.Add("wraithspear", "AB_Illusion_WraithSpear_AbilityGroup")
			.Add("veilofillusion", "AB_Vampire_VeilOfIllusion_AbilityGroup")
			.Add("balllightning", "AB_Storm_BallLightning_AbilityGroup")
			.Add("cyclone", "AB_Storm_Cyclone_AbilityGroup")
			.Add("discharge", "AB_Storm_Discharge_AbilityGroup")
			.Add("lightningwall", "AB_Storm_LightningWall_AbilityGroup")
			.Add("polarityshift", "AB_Storm_PolarityShift_AbilityGroup")
			.Add("veilofstorm", "AB_Vampire_VeilOfStorm_Group")
			.Add("corpseexplosion", "AB_Unholy_CorpseExplosion_AbilityGroup")
			.Add("corruptedskull", "AB_Unholy_CorruptedSkull_AbilityGroup")
			.Add("deathknight", "AB_Unholy_DeathKnight_AbilityGroup")
			.Add("soulburn", "AB_Unholy_Soulburn_AbilityGroup")
			.Add("wardofthedamned", "AB_Unholy_WardOfTheDamned_AbilityGroup")
			.Add("veilofbones", "AB_Vampire_VeilOfBones_AbilityGroup");

		public static int RequiredItemGUID { get; set; }

		public static string ItemName { get; set; } = "Unknown Item";


		public static int RequiredItemAmount { get; set; }

		public static string GetColorForSkill(string skillName)
		{
			string text = skillName.ToLower();
			if (SkillClass.ContainsKey(text))
			{
				return text switch
				{
					"blood" => "red", 
					"chaos" => "#B19CD9", 
					"frost" => "#87CEFA", 
					"illusion" => "#90ee90", 
					"storm" => "yellow", 
					"unholy" => "green", 
					_ => "white", 
				};
			}
			foreach (KeyValuePair<string, List<string>> item in SkillClass)
			{
				if (item.Value.Contains(text))
				{
					return item.Key.ToLower() switch
					{
						"blood" => "red", 
						"chaos" => "#B19CD9", 
						"frost" => "#87CEFA", 
						"illusion" => "#90ee90", 
						"storm" => "yellow", 
						"unholy" => "green", 
						_ => "white", 
					};
				}
			}
			return "white";
		}

		public static void inits()
		{
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd = SkillModList.GetOrAdd("bloodfountain", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd.TryAdd("1", new CreateJevelLegendStruct("SpellMod_BloodFountain_FirstImpactApplyLeech", SkillPower, "Initial hit inflicts Leech."));
			orAdd.TryAdd("2", new CreateJevelLegendStruct("SpellMod_BloodFountain_FirstImpactDispell", SkillPower, "Removes negative effects."));
			orAdd.TryAdd("3", new CreateJevelLegendStruct("SpellMod_BloodFountain_FirstImpactFadingSnare", SkillPower, "Initial impact inflicts fading snare."));
			orAdd.TryAdd("4", new CreateJevelLegendStruct("SpellMod_BloodFountain_FirstImpactHealIncrease", SkillPower, "Increases initial hit healing."));
			orAdd.TryAdd("5", new CreateJevelLegendStruct("SpellMod_BloodFountain_RecastLesser", SkillPower, "Recast to conjure a lesser blood fountain."));
			orAdd.TryAdd("6", new CreateJevelLegendStruct("SpellMod_BloodFountain_SecondImpactDamageIncrease", SkillPower, "Eruption impact deals bonus damage."));
			orAdd.TryAdd("7", new CreateJevelLegendStruct("SpellMod_BloodFountain_SecondImpactHealIncrease", SkillPower, "Increases eruption healing."));
			orAdd.TryAdd("8", new CreateJevelLegendStruct("SpellMod_BloodFountain_SecondImpactKnockback", SkillPower, "Eruption hit knocks enemies back."));
			orAdd.TryAdd("9", new CreateJevelLegendStruct("SpellMod_BloodFountain_SecondImpactSpeedBuff", SkillPower, "Eruption hit increases ally movement speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd2 = SkillModList.GetOrAdd("bloodrage", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd2.TryAdd("1", new CreateJevelLegendStruct("SpellMod_BloodRage_DamageBoost", SkillPower, "Increases physical damage output during effect."));
			orAdd2.TryAdd("2", new CreateJevelLegendStruct("SpellMod_BloodRage_HealOnKill", SkillPower, "Killing an enemy during effect heals you."));
			orAdd2.TryAdd("3", new CreateJevelLegendStruct("SpellMod_BloodRage_IncreaseLifetime", SkillPower, "Extends effect duration."));
			orAdd2.TryAdd("4", new CreateJevelLegendStruct("SpellMod_BloodRage_IncreaseMoveSpeed", SkillPower, "Boosts movement speed."));
			orAdd2.TryAdd("5", new CreateJevelLegendStruct("SpellMod_BloodRage_Shield", SkillPower, "Shields self and nearby allies."));
			orAdd2.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_ApplyFadingSnare_Medium", SkillPower, "Inflicts fading snare."));
			orAdd2.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_DispellDebuffs", SkillPower, "Removes negative effects."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd3 = SkillModList.GetOrAdd("bloodrite", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd3.TryAdd("1", new CreateJevelLegendStruct("SpellMod_BloodRite_ApplyFadingSnare", SkillPower, "Inflicts fading snare on enemies."));
			orAdd3.TryAdd("2", new CreateJevelLegendStruct("SpellMod_BloodRite_BonusDamage", SkillPower, "Increases damage."));
			orAdd3.TryAdd("3", new CreateJevelLegendStruct("SpellMod_BloodRite_DamageOnAttack", SkillPower, "Next primary attack deals bonus damage."));
			orAdd3.TryAdd("4", new CreateJevelLegendStruct("SpellMod_BloodRite_HealOnTrigger", SkillPower, "When triggered, heals self."));
			orAdd3.TryAdd("5", new CreateJevelLegendStruct("SpellMod_BloodRite_IncreaseLifetime", SkillPower, "Extends immaterial duration."));
			orAdd3.TryAdd("6", new CreateJevelLegendStruct("SpellMod_BloodRite_Stealth", SkillPower, "Turn invisible during immaterial duration."));
			orAdd3.TryAdd("7", new CreateJevelLegendStruct("SpellMod_BloodRite_TossDaggers", SkillPower, "Throw daggers at nearby enemies."));
			orAdd3.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_High", SkillPower, "Increases movement speed when channeling."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd4 = SkillModList.GetOrAdd("sanguinecoil", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd4.TryAdd("1", new CreateJevelLegendStruct("SpellMod_SanguineCoil_AddBounces", SkillPower, "Bounces to an additional target after first hit."));
			orAdd4.TryAdd("2", new CreateJevelLegendStruct("SpellMod_SanguineCoil_BonusDamage", SkillPower, "Increases damage."));
			orAdd4.TryAdd("3", new CreateJevelLegendStruct("SpellMod_SanguineCoil_BonusHealing", SkillPower, "Boosts ally healing."));
			orAdd4.TryAdd("4", new CreateJevelLegendStruct("SpellMod_SanguineCoil_BonusLifeLeech", SkillPower, "Enhances life drain."));
			orAdd4.TryAdd("5", new CreateJevelLegendStruct("SpellMod_SanguineCoil_KillRecharge", SkillPower, "Lethal attacks restore one charge."));
			orAdd4.TryAdd("6", new CreateJevelLegendStruct("SpellMod_SanguineCoil_LeechBonusDamage", SkillPower, "Hitting targets with Leech deals bonus damage."));
			orAdd4.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_AddCharges", SkillPower, "Increases maximum charges."));
			orAdd4.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd5 = SkillModList.GetOrAdd("shadowbolt", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd5.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shadowbolt_ExplodeOnHit", SkillPower, "Explodes on hit inflicting Leech on nearby enemies."));
			orAdd5.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Shadowbolt_LeechBonusDamage", SkillPower, "Hitting targets with Leech deals bonus damage."));
			orAdd5.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shadowbolt_VampiricCurse", SkillPower, "Inflicts Vampiric Curse."));
			orAdd5.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Blood_ConsumeLeechSelfHeal_Small", SkillPower, "Hitting targets with Leech heals self."));
			orAdd5.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_CastRate", SkillPower, "Increases cast rate."));
			orAdd5.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Cooldown_Medium", SkillPower, "Reduces cooldown."));
			orAdd5.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_KnockbackOnHit_Medium", SkillPower, "Knocks targets back on hit."));
			orAdd5.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd6 = SkillModList.GetOrAdd("veilofblood", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd6.TryAdd("1", new CreateJevelLegendStruct("SpellMod_VeilOfBlood_AttackInflictFadingSnare", SkillPower, "Next primary attack inflicts fading snare."));
			orAdd6.TryAdd("2", new CreateJevelLegendStruct("SpellMod_VeilOfBlood_DashInflictLeech", SkillPower, "Dashing through an enemy inflicts Leech."));
			orAdd6.TryAdd("3", new CreateJevelLegendStruct("SpellMod_VeilOfBlood_Empower", SkillPower, "Hitting enemies with Leech boosts your physical damage."));
			orAdd6.TryAdd("4", new CreateJevelLegendStruct("SpellMod_VeilOfBlood_SelfHealing", SkillPower, "Increases maximum healing percentage."));
			orAdd6.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd6.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd7 = SkillModList.GetOrAdd("aftershock", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd7.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Chaos_Aftershock_BonusDamage", SkillPower, "Increases damage."));
			orAdd7.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Chaos_Aftershock_InflictSlowOnProjectile", SkillPower, "Initial wave inflicts fading snare."));
			orAdd7.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Chaos_Aftershock_KnockbackArea", SkillPower, "Knocks nearby enemies back on cast."));
			orAdd7.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Chaos_ConsumeIgniteAgonizingFlames", SkillPower, "Hitting targets with Ignite engulfs them in flames, dealing damage and healing self over time."));
			orAdd7.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Cooldown_Medium", SkillPower, "Reduces cooldown."));
			orAdd7.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_IncreaseRange_Medium", SkillPower, "Increases projectile range."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd8 = SkillModList.GetOrAdd("chaosbarrier", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd8.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Chaos_Barrier_BonusDamage", SkillPower, "Increases damage per charge."));
			orAdd8.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Chaos_Barrier_ConsumeAttackReduceCooldownXTimes", SkillPower, "Absorbing attacks reduces cooldown."));
			orAdd8.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Chaos_Barrier_ExplodeOnHit", SkillPower, "Explodes on hit, dealing damage and inflicting Ignite on nearby enemies."));
			orAdd8.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Chaos_Barrier_LesserPowerSurge", SkillPower, "When fully charged, gain a lesser Power Surge for a short duration."));
			orAdd8.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Chaos_Barrier_StunOnHit", SkillPower, "Charged chaos bolt stuns target on hit."));
			orAdd8.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_Low", SkillPower, "Increases movement speed when channeling."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd9 = SkillModList.GetOrAdd("powersurge", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd9.TryAdd("1", new CreateJevelLegendStruct("SpellMod_PowerSurge_AttackSpeed", SkillPower, "Boosts attack speed during effect."));
			orAdd9.TryAdd("2", new CreateJevelLegendStruct("SpellMod_PowerSurge_EmpowerPhysical", SkillPower, "Increases physical damage output during effect."));
			orAdd9.TryAdd("3", new CreateJevelLegendStruct("SpellMod_PowerSurge_Haste", SkillPower, "Increases movement speed during effect."));
			orAdd9.TryAdd("4", new CreateJevelLegendStruct("SpellMod_PowerSurge_IncreaseDurationOnKill", SkillPower, "extend duration."));
			orAdd9.TryAdd("5", new CreateJevelLegendStruct("SpellMod_PowerSurge_Lifetime", SkillPower, "Extends effect duration."));
			orAdd9.TryAdd("6", new CreateJevelLegendStruct("SpellMod_PowerSurge_RecastDestonate", SkillPower, "Recast to consume effect."));
			orAdd9.TryAdd("7", new CreateJevelLegendStruct("SpellMod_PowerSurge_Shield", SkillPower, "Shields target."));
			orAdd9.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_DispellDebuffs", SkillPower, "Removes negative effects."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd10 = SkillModList.GetOrAdd("void", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd10.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Chaos_Void_BonusDamage", SkillPower, "Increases damage."));
			orAdd10.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Chaos_Void_BurnArea", SkillPower, "Flames engulf area, dealing damage over time."));
			orAdd10.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Chaos_Void_FragBomb", SkillPower, "Spawns exploding fragments, dealing damage and inflicting Ignite."));
			orAdd10.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Chaos_Void_ReduceChargeCD", SkillPower, "Charges recharge faster."));
			orAdd10.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Chaos_ConsumeIgniteAgonizingFlames", SkillPower, "Dealing damage and healing self over time."));
			orAdd10.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_TargetAoE_IncreaseRange_Medium", SkillPower, "Increases range."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd11 = SkillModList.GetOrAdd("volley", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd11.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Chaos_Volley_BonusDamage", SkillPower, "Increases damage."));
			orAdd11.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Chaos_Volley_SecondProjectileBonusDamage", SkillPower, "different target hit deals bonus damage."));
			orAdd11.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Chaos_ConsumeIgniteAgonizingFlames", SkillPower, "Dealing damage and healing self over time."));
			orAdd11.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Cooldown_Medium", SkillPower, "Reduces cooldown."));
			orAdd11.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_KnockbackOnHit_Light", SkillPower, "Knocks targets back on hit."));
			orAdd11.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd12 = SkillModList.GetOrAdd("veilofchaos", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd12.TryAdd("1", new CreateJevelLegendStruct("SpellMod_VeilOfChaos_ApplySnareOnExplode", SkillPower, "Illusion explosion inflicts fading snare."));
			orAdd12.TryAdd("2", new CreateJevelLegendStruct("SpellMod_VeilOfChaos_BonusDamageOnExplode", SkillPower, "Increases damage when illusion explodes."));
			orAdd12.TryAdd("3", new CreateJevelLegendStruct("SpellMod_VeilOfChaos_BonusIllusion", SkillPower, "Spawns second illusion on recast, dealing reduced damage."));
			orAdd12.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Chaos_ConsumeIgniteAgonizingFlames_OnAttack", SkillPower, "Dealing damage and healing self over time.."));
			orAdd12.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd12.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd13 = SkillModList.GetOrAdd("coldsnap", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd13.TryAdd("1", new CreateJevelLegendStruct("SpellMod_ColdSnap_BonusAbsorb", SkillPower, "Shield absorbs more of your spell power."));
			orAdd13.TryAdd("2", new CreateJevelLegendStruct("SpellMod_ColdSnap_BonusDamage", SkillPower, "Increases damage."));
			orAdd13.TryAdd("3", new CreateJevelLegendStruct("SpellMod_ColdSnap_HasteWhileShielded", SkillPower, "Increases movement speed while shielded."));
			orAdd13.TryAdd("4", new CreateJevelLegendStruct("SpellMod_ColdSnap_Immaterial", SkillPower, "Become immaterial when triggered."));
			orAdd13.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Frost_IncreaseFreezeWhenChill", SkillPower, "Freeze lasts longer on Chilled targets."));
			orAdd13.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_FrostWeapon", SkillPower, "Next attack deals bonus damage and inflicts Chill."));
			orAdd13.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_High", SkillPower, "Increases movement speed when channeling."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd14 = SkillModList.GetOrAdd("crystallance", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd14.TryAdd("1", new CreateJevelLegendStruct("SpellMod_CrystalLance_BonusDamageToFrosty", SkillPower, "Increases damage to Chilled and Frozen targets."));
			orAdd14.TryAdd("2", new CreateJevelLegendStruct("SpellMod_CrystalLance_PierceEnemies", SkillPower, "Pierces multiple targets, reducing damage per target."));
			orAdd14.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_CastRate", SkillPower, "Increases cast rate."));
			orAdd14.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Frost_IncreaseFreezeWhenChill", SkillPower, "Freeze lasts longer on Chilled targets."));
			orAdd14.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Frost_ShieldOnFrosty", SkillPower, "Hitting Chilled or Frozen target shields you."));
			orAdd14.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd15 = SkillModList.GetOrAdd("frostbarrier", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd15.TryAdd("1", new CreateJevelLegendStruct("SpellMod_FrostBarrier_BonusDamage", SkillPower, "Increases damage."));
			orAdd15.TryAdd("2", new CreateJevelLegendStruct("SpellMod_FrostBarrier_BonusSpellPowerOnAbsorb", SkillPower, "Absorbing an attack boosts your spell power."));
			orAdd15.TryAdd("3", new CreateJevelLegendStruct("SpellMod_FrostBarrier_ConsumeAttackReduceCooldownXTimes", SkillPower, "Absorbing attacks reduces cooldown, up to several times."));
			orAdd15.TryAdd("4", new CreateJevelLegendStruct("SpellMod_FrostBarrier_KnockbackOnRecast", SkillPower, "Cone of cold knocks targets back on hit."));
			orAdd15.TryAdd("5", new CreateJevelLegendStruct("SpellMod_FrostBarrier_ShieldOnFrostyRecast", SkillPower, "Hitting Chilled or Frozen target with cone of cold shields you."));
			orAdd15.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Frost_ConsumeChillIntoFreeze_Recast", SkillPower, "Cone of cold consumes Chill to inflict Freeze."));
			orAdd15.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_Low", SkillPower, "Increases movement speed when channeling."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd16 = SkillModList.GetOrAdd("frostbat", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd16.TryAdd("1", new CreateJevelLegendStruct("SpellMod_FrostBat_AreaDamage", SkillPower, "Frost impact blast damages surrounding enemies."));
			orAdd16.TryAdd("2", new CreateJevelLegendStruct("SpellMod_FrostBat_BonusDamageToFrosty", SkillPower, "Increases damage to Chilled and Frozen targets."));
			orAdd16.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_CastRate", SkillPower, "Increases cast rate."));
			orAdd16.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Frost_SplinterNovaOnFrosty", SkillPower, "Hitting Chilled or Frozen target shatters projectile into splinters."));
			orAdd16.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Frost_ShieldOnFrosty", SkillPower, "Hitting Chilled or Frozen target shields you."));
			orAdd16.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd17 = SkillModList.GetOrAdd("icenova", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd17.TryAdd("1", new CreateJevelLegendStruct("SpellMod_IceNova_ApplyShield", SkillPower, "Nova shields self and allies."));
			orAdd17.TryAdd("2", new CreateJevelLegendStruct("SpellMod_IceNova_BonusDamageToFrosty", SkillPower, "Increases damage to Chilled and Frozen targets."));
			orAdd17.TryAdd("3", new CreateJevelLegendStruct("SpellMod_IceNova_RecastLesserNova", SkillPower, "Recast to conjure lesser ice nova dealing reduced damage."));
			orAdd17.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Cooldown_Medium", SkillPower, "Reduces cooldown."));
			orAdd17.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_TargetAoE_IncreaseRange_Medium", SkillPower, "Increases range."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd18 = SkillModList.GetOrAdd("veiloffrost", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd18.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_Frost_ConsumeChillIntoFreeze_OnAttack", SkillPower, "Next primary attack consumes Chill to inflict Freeze."));
			orAdd18.TryAdd("2", new CreateJevelLegendStruct("SpellMod_VeilOfFrost_FrostNova", SkillPower, "Next primary attack conjures frost nova, dealing damage and inflicting Chill."));
			orAdd18.TryAdd("3", new CreateJevelLegendStruct("SpellMod_VeilOfFrost_IllusionFrostBlast", SkillPower, "Illusion explodes in ice nova, dealing damage and inflicting Chill."));
			orAdd18.TryAdd("4", new CreateJevelLegendStruct("SpellMod_VeilOfFrost_ShieldBonus", SkillPower, "Increases shield absorb amount."));
			orAdd18.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd18.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd19 = SkillModList.GetOrAdd("misttrance", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd19.TryAdd("1", new CreateJevelLegendStruct("SpellMod_MIstTrance_DamageOnAttack", SkillPower, "When triggered, next primary attack deals bonus damage."));
			orAdd19.TryAdd("2", new CreateJevelLegendStruct("SpellMod_MistTrance_FearOnTrigger", SkillPower, "When triggered, fears nearby enemies."));
			orAdd19.TryAdd("3", new CreateJevelLegendStruct("SpellMod_MistTrance_HasteOnTrigger", SkillPower, "When triggered, increases movement speed for a short duration."));
			orAdd19.TryAdd("4", new CreateJevelLegendStruct("SpellMod_MistTrance_PhantasmOnTrigger", SkillPower, "When triggered, grants stacks of Phantasm."));
			orAdd19.TryAdd("5", new CreateJevelLegendStruct("SpellMod_MistTrance_ReduceSecondaryWeaponCD", SkillPower, "When triggered, reduces cooldown of secondary weapon skill."));
			orAdd19.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_High", SkillPower, "Increases movement speed when channeling."));
			orAdd19.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_KnockbackOnHit_Medium", SkillPower, "Knocks targets back on hit."));
			orAdd19.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_TravelBuff_IncreaseRange_Medium", SkillPower, "Increases distance traveled."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd20 = SkillModList.GetOrAdd("mosquito", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd20.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Mosquito_BonusDamage", SkillPower, "Increases damage."));
			orAdd20.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Mosquito_BonusFearDuration", SkillPower, "Extends duration of fear."));
			orAdd20.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Mosquito_BonusHealthAndSpeed", SkillPower, "Increases mosquito's health."));
			orAdd20.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Mosquito_ShieldOnSpawn", SkillPower, "Shields nearby allies when mosquito is summoned."));
			orAdd20.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Mosquito_WispsOnDestroy", SkillPower, "Spawns wisps healing self or allies when mosquito explodes."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd21 = SkillModList.GetOrAdd("phantomaegis", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd21.TryAdd("1", new CreateJevelLegendStruct("SpellMod_PhantomAegis_ConsumeShieldAndPullAlly", SkillPower, "Recast to consume barrier from an ally."));
			orAdd21.TryAdd("2", new CreateJevelLegendStruct("SpellMod_PhantomAegis_ExplodeOnDestroy", SkillPower, "Barrier explodes if destroyed, inflicting Fear on nearby enemies."));
			orAdd21.TryAdd("3", new CreateJevelLegendStruct("SpellMod_PhantomAegis_IncreaseLifetime", SkillPower, "Extends barrier's lifetime."));
			orAdd21.TryAdd("4", new CreateJevelLegendStruct("SpellMod_PhantomAegis_IncreaseSpellPower", SkillPower, "Increases target's spell power while barrier lasts."));
			orAdd21.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_DispellDebuffs", SkillPower, "Removes negative effects."));
			orAdd21.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_KnockbackOnHit_Medium", SkillPower, "Knocks targets back on hit."));
			orAdd21.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_MovementSpeed_Normal", SkillPower, "Increases movement speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd22 = SkillModList.GetOrAdd("spectralwolf", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd22.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_Illusion_ConsumeWeakenSpawnWisp", SkillPower, "Consumes Weaken to spawn a wisp, healing self or ally."));
			orAdd22.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Shared_Illusion_WeakenShield", SkillPower, "Hitting target with Weaken grants you a shield."));
			orAdd22.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			orAdd22.TryAdd("4", new CreateJevelLegendStruct("SpellMod_SpectralWolf_AddBounces", SkillPower, "Increases maximum bounces."));
			orAdd22.TryAdd("5", new CreateJevelLegendStruct("SpellMod_SpectralWolf_DecreaseBounceDamageReduction", SkillPower, "Reduces damage penalty per bounce."));
			orAdd22.TryAdd("6", new CreateJevelLegendStruct("SpellMod_SpectralWolf_FirstBounceInflictFadingSnare", SkillPower, "Initial projectile inflicts fading snare on enemies hit."));
			orAdd22.TryAdd("7", new CreateJevelLegendStruct("SpellMod_SpectralWolf_ReturnToOwner", SkillPower, "Wolf returns after last bounce, healing you."));
			orAdd22.TryAdd("8", new CreateJevelLegendStruct("SpellMod_SpectralWolf_WeakenApplyXPhantasm", SkillPower, "Hitting target with Weaken grants stacks of Phantasm."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd23 = SkillModList.GetOrAdd("wraithspear", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd23.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_ApplyFadingSnare_Medium", SkillPower, "Inflicts fading snare on enemies hit."));
			orAdd23.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Shared_Illusion_ConsumeWeakenSpawnWisp", SkillPower, "Consumes Weaken to spawn a wisp, healing self or ally."));
			orAdd23.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Illusion_WeakenShield", SkillPower, "Hitting target with Weaken grants you a shield, stacking multiple times."));
			orAdd23.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_IncreaseRange_Medium", SkillPower, "Increases projectile range."));
			orAdd23.TryAdd("5", new CreateJevelLegendStruct("SpellMod_WraithSpear_BonusDamage", SkillPower, "Increases damage."));
			orAdd23.TryAdd("6", new CreateJevelLegendStruct("SpellMod_WraithSpear_ReducedDamageReduction", SkillPower, "Reduces damage penalty per hit."));
			orAdd23.TryAdd("7", new CreateJevelLegendStruct("SpellMod_WraithSpear_ShieldAlly", SkillPower, "Hitting an ally shields them."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd24 = SkillModList.GetOrAdd("veilofillusion", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd24.TryAdd("1", new CreateJevelLegendStruct("SpellMod_VeilOfIllusion_AttackInflictFadingSnare", SkillPower, "Next primary attack inflicts fading snare."));
			orAdd24.TryAdd("2", new CreateJevelLegendStruct("SpellMod_VeilOfIllusion_IllusionProjectileDamage", SkillPower, "Illusion projectiles deal damage."));
			orAdd24.TryAdd("3", new CreateJevelLegendStruct("SpellMod_VeilOfIllusion_PhantasmOnHit", SkillPower, "Next primary attack grants stacks of Phantasm."));
			orAdd24.TryAdd("4", new CreateJevelLegendStruct("SpellMod_VeilOfIllusion_RecastDetonate", SkillPower, "Detonate your illusion on recast, dealing damage and inflicting Weaken."));
			orAdd24.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd24.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			orAdd24.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_Illusion_WeakenShield_OnAttack", SkillPower, "Hitting enemy with Weaken grants shield, stacking multiple times."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd25 = SkillModList.GetOrAdd("balllightning", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd25.TryAdd("1", new CreateJevelLegendStruct("SpellMod_BallLightning_BonusDamage", SkillPower, "Increases damage per shock."));
			orAdd25.TryAdd("2", new CreateJevelLegendStruct("SpellMod_BallLightning_DetonateOnRecast", SkillPower, "Recast to detonate orb early, explosion deals increased damage."));
			orAdd25.TryAdd("3", new CreateJevelLegendStruct("SpellMod_BallLightning_Haste", SkillPower, "Increases allies' movement speed when orb explodes."));
			orAdd25.TryAdd("4", new CreateJevelLegendStruct("SpellMod_BallLightning_KnockbackOnExplode", SkillPower, "Knocks enemies back when orb explodes."));
			orAdd25.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_IncreaseRange_Medium", SkillPower, "Increases projectile range."));
			orAdd25.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Storm_ConsumeStaticIntoStun_Explode", SkillPower, "Consumes Static to stun enemies when orb explodes."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd26 = SkillModList.GetOrAdd("cyclone", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd26.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Cyclone_BonusDamage", SkillPower, "Increases damage."));
			orAdd26.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Cyclone_IncreaseLifetime", SkillPower, "Extends projectile lifetime."));
			orAdd26.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			orAdd26.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Shared_Storm_ConsumeStaticIntoStun", SkillPower, "Consumes Static to stun target."));
			orAdd26.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Storm_ConsumeStaticIntoWeaponCharge", SkillPower, "Consumes Static to charge weapon."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd27 = SkillModList.GetOrAdd("discharge", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd27.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Discharge_BonusDamage", SkillPower, "Increases damage done by storm shields."));
			orAdd27.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Discharge_Immaterial", SkillPower, "Become immaterial if you have multiple storm shields when effect ends."));
			orAdd27.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Discharge_IncreaseStunDuration", SkillPower, "Extends stun duration."));
			orAdd27.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Discharge_RecastDetonate", SkillPower, "Recast to end effect, triggering explosion and knocking back enemies."));
			orAdd27.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Discharge_SpellLeech", SkillPower, "Each active storm shield grants spell life leech."));
			orAdd27.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_High", SkillPower, "Increases movement speed when channeling."));
			orAdd27.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_Storm_GrantWeaponCharge", SkillPower, "When triggered, charges weapon, boosting next attack and inflicting Static."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd28 = SkillModList.GetOrAdd("lightningwall", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd28.TryAdd("1", new CreateJevelLegendStruct("SpellMod_LightningWall_ApplyShield", SkillPower, "Passing through wall shields ally."));
			orAdd28.TryAdd("2", new CreateJevelLegendStruct("SpellMod_LightningWall_BonusDamage", SkillPower, "Increases damage per hit."));
			orAdd28.TryAdd("3", new CreateJevelLegendStruct("SpellMod_LightningWall_ConsumeProjectileWeaponCharge", SkillPower, "Blocking projectiles charges weapon."));
			orAdd28.TryAdd("4", new CreateJevelLegendStruct("SpellMod_LightningWall_FadingSnare", SkillPower, "Inflicts fading snare on initial hit."));
			orAdd28.TryAdd("5", new CreateJevelLegendStruct("SpellMod_LightningWall_IncreaseMovementSpeed", SkillPower, "Increases movement speed when passing through wall."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd29 = SkillModList.GetOrAdd("polarityshift", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd29.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_ApplyFadingSnare_Medium", SkillPower, "Inflicts fading snare on enemies hit."));
			orAdd29.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			orAdd29.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Storm_ConsumeStaticIntoWeaponCharge", SkillPower, "Consumes Static to charge weapon, boosting next attack and inflicting Static."));
			orAdd29.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Storm_PolarityShift_AreaImpactDestination", SkillPower, "Triggers lightning nova at destination, dealing damage and inflicting Static."));
			orAdd29.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Storm_PolarityShift_AreaImpactOrigin", SkillPower, "Triggers lightning nova at origin, dealing damage and inflicting Static."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd30 = SkillModList.GetOrAdd("veilofstorm", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd30.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_Storm_ConsumeStaticIntoStun", SkillPower, "Consumes Static to stun target."));
			orAdd30.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd30.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			orAdd30.TryAdd("4", new CreateJevelLegendStruct("SpellMod_VeilOfStorm_AttackInflictFadingSnare", SkillPower, "Next primary attack inflicts fading snare."));
			orAdd30.TryAdd("5", new CreateJevelLegendStruct("SpellMod_VeilOfStorm_DashInflictStatic", SkillPower, "Dashing through an enemy inflicts Static."));
			orAdd30.TryAdd("6", new CreateJevelLegendStruct("SpellMod_VeilOfStorm_SparklingIllusion", SkillPower, "Illusion periodically shocks nearby enemy."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd31 = SkillModList.GetOrAdd("deathknight", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd31.TryAdd("1", new CreateJevelLegendStruct("SpellMod_DeathKnight_BonusDamage", SkillPower, "Increases damage."));
			orAdd31.TryAdd("2", new CreateJevelLegendStruct("SpellMod_DeathKnight_IncreaseLifetime", SkillPower, "Extends Death Knight's lifetime."));
			orAdd31.TryAdd("3", new CreateJevelLegendStruct("SpellMod_DeathKnight_LifeLeech", SkillPower, "Damage done by the Death Knight heals you."));
			orAdd31.TryAdd("4", new CreateJevelLegendStruct("SpellMod_DeathKnight_MaxHealth", SkillPower, "Increases Death Knight's health."));
			orAdd31.TryAdd("5", new CreateJevelLegendStruct("SpellMod_DeathKnight_SkeletonMageOnLifetimeEnded", SkillPower, "Summons a Skeleton Mage when Death Knight's lifetime expires."));
			orAdd31.TryAdd("6", new CreateJevelLegendStruct("SpellMod_DeathKnight_SnareEnemiesOnSummon", SkillPower, "Inflicts fading snare on enemies near the summoning location."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd32 = SkillModList.GetOrAdd("soulburn", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd32.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_DispellDebuffs_Self", SkillPower, "Removes negative effects from self when cast."));
			orAdd32.TryAdd("2", new CreateJevelLegendStruct("SpellMod_Soulburn_BonusDamage", SkillPower, "Increases damage."));
			orAdd32.TryAdd("3", new CreateJevelLegendStruct("SpellMod_Soulburn_BonusLifeDrain", SkillPower, "Increases life drain."));
			orAdd32.TryAdd("4", new CreateJevelLegendStruct("SpellMod_Soulburn_ConsumeSkeletonEmpower", SkillPower, "Consumes up to three allied skeletons increasing  spell and physical power."));
			orAdd32.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Soulburn_ConsumeSkeletonHeal", SkillPower, "Consumes up to three allied skeletons, healing you per skeleton."));
			orAdd32.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Soulburn_IncreasedSilenceDuration", SkillPower, "Increases silence duration."));
			orAdd32.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Soulburn_IncreaseTriggerCount", SkillPower, "Increases targets hit."));
			orAdd32.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Soulburn_ReduceCooldownOnSilence", SkillPower, "Reduces cooldown for each target silenced."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd33 = SkillModList.GetOrAdd("wardofthedamned", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd33.TryAdd("1", new CreateJevelLegendStruct("SpellMod_Shared_IncreaseMoveSpeedDuringChannel_Low", SkillPower, "Increases movement speed while channeling."));
			orAdd33.TryAdd("2", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_BonusDamageOnRecast", SkillPower, "Increases damage of recast attack."));
			orAdd33.TryAdd("3", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_DamageMeleeAttackers", SkillPower, "Melee attackers take damage when striking the barrier."));
			orAdd33.TryAdd("4", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_EmpowerSkeletonsOnRecast", SkillPower, "Empowers allied skeletons hit by recast."));
			orAdd33.TryAdd("5", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_HealOnAbsorbProjectile", SkillPower, "Absorbing a projectile heals you."));
			orAdd33.TryAdd("6", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_KnockbackOnRecast", SkillPower, "Recast attack knocks targets back on hit."));
			orAdd33.TryAdd("7", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_MightSpawnMageSkeleton", SkillPower, "Chance to spawn a Skeleton Mage instead."));
			orAdd33.TryAdd("8", new CreateJevelLegendStruct("SpellMod_WardOfTheDamned_ShieldSkeletonsOnRecast", SkillPower, "Shields allied skeletons hit by recast."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd34 = SkillModList.GetOrAdd("veilofbones", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd34.TryAdd("1", new CreateJevelLegendStruct("SpellMod_VeilOfBones_BonusDamageBelowThreshold", SkillPower, "Increases damage to targets below critical health."));
			orAdd34.TryAdd("2", new CreateJevelLegendStruct("SpellMod_VeilOfBones_DashHealMinions", SkillPower, "Heals allied skeletons you dash through and resets their lifetime."));
			orAdd34.TryAdd("3", new CreateJevelLegendStruct("SpellMod_VeilOfBones_DashInflictCondemn", SkillPower, "Dashing through an enemy inflicts Condemn."));
			orAdd34.TryAdd("4", new CreateJevelLegendStruct("SpellMod_VeilOfBones_SpawnSkeletonMage", SkillPower, "Striking an enemy summons a Skeleton Mage instead of a Skeleton Warrior."));
			orAdd34.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BonusDamageOnPrimary", SkillPower, "Increases next primary attack damage."));
			orAdd34.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Veil_BuffAndIllusionDuration", SkillPower, "Extends elude duration."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd35 = SkillModList.GetOrAdd("corruptedskull", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd35.TryAdd("1", new CreateJevelLegendStruct("SpellMod_CorruptedSkull_BoneSpirit", SkillPower, "Summons a bone spirit."));
			orAdd35.TryAdd("2", new CreateJevelLegendStruct("SpellMod_CorruptedSkull_BonusDamage", SkillPower, "Boosts damage."));
			orAdd35.TryAdd("3", new CreateJevelLegendStruct("SpellMod_CorruptedSkull_DetonateSkeleton", SkillPower, "Explodes an allied skeleton, dealing damage and inflicting Condemn."));
			orAdd35.TryAdd("4", new CreateJevelLegendStruct("SpellMod_CorruptedSkull_LesserProjectiles", SkillPower, "Launches two spiraling projectiles, each dealing less damage."));
			orAdd35.TryAdd("5", new CreateJevelLegendStruct("SpellMod_Shared_KnockbackOnHit_Medium", SkillPower, "Knocks targets back on hit."));
			orAdd35.TryAdd("6", new CreateJevelLegendStruct("SpellMod_Shared_Projectile_RangeAndVelocity", SkillPower, "Increases projectile range and speed."));
			ConcurrentDictionary<string, CreateJevelLegendStruct> orAdd36 = SkillModList.GetOrAdd("corpseexplosion", new ConcurrentDictionary<string, CreateJevelLegendStruct>());
			orAdd36.TryAdd("1", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_BonusDamage", SkillPower, "Boosts damage."));
			orAdd36.TryAdd("2", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_DoubleImpact", SkillPower, "Triggers a second explosion dealing damage."));
			orAdd36.TryAdd("3", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_HealMinions", SkillPower, "Heals allied skeletons and resets lifetime."));
			orAdd36.TryAdd("4", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_KillingBlow", SkillPower, "Deals bonus damage to low-health enemies."));
			orAdd36.TryAdd("5", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_SkullNova", SkillPower, "Spawns a nova of projectiles that deal damage and inflict Condemn."));
			orAdd36.TryAdd("6", new CreateJevelLegendStruct("SpellMod_CorpseExplosion_SnareBonus", SkillPower, "Applies a short snare on enemies."));
			orAdd36.TryAdd("7", new CreateJevelLegendStruct("SpellMod_Shared_Cooldown_Medium", SkillPower, "Reduces cooldown."));
			orAdd36.TryAdd("8", new CreateJevelLegendStruct("SpellMod_Shared_TargetAoE_IncreaseRange_Medium", SkillPower, "Increases range."));
		}
	}
	public struct CreateJevelLegendStruct
	{
		public string Mod { get; set; }

		public float Power { get; set; }

		public string Description { get; set; }

		public CreateJevelLegendStruct(string mod = "", float power = 1f, string desc = "null")
		{
			Mod = mod;
			Power = power;
			Description = desc;
		}
	}
}