using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
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 BepInEx.Unity.IL2CPP.Utils;
using Dead;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using Rewired.Utils;
using TinyJson;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.SceneManagement;
using WildfrostModMiya.Hook.Dobby;
using WildfrostModMiya.Hook.Funchook;

[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("WildfrostModMiya")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+da5f2cc78e0f5c8872cd31a724143aabfe9c5a5e")]
[assembly: AssemblyProduct("WildfrostModMiya")]
[assembly: AssemblyTitle("WildfrostModMiya")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
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 NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = P_0;
		}
	}
}
namespace TinyJson
{
	public static class JSONParser
	{
		[ThreadStatic]
		private static Stack<List<string>> splitArrayPool;

		[ThreadStatic]
		private static StringBuilder stringBuilder;

		[ThreadStatic]
		private static Dictionary<Type, Dictionary<string, FieldInfo>> fieldInfoCache;

		[ThreadStatic]
		private static Dictionary<Type, Dictionary<string, PropertyInfo>> propertyInfoCache;

		public static T FromJson<T>(this string json)
		{
			if (propertyInfoCache == null)
			{
				propertyInfoCache = new Dictionary<Type, Dictionary<string, PropertyInfo>>();
			}
			if (fieldInfoCache == null)
			{
				fieldInfoCache = new Dictionary<Type, Dictionary<string, FieldInfo>>();
			}
			if (stringBuilder == null)
			{
				stringBuilder = new StringBuilder();
			}
			if (splitArrayPool == null)
			{
				splitArrayPool = new Stack<List<string>>();
			}
			stringBuilder.Length = 0;
			for (int i = 0; i < json.Length; i++)
			{
				char c = json[i];
				if (c == '"')
				{
					i = AppendUntilStringEnd(appendEscapeCharacter: true, i, json);
				}
				else if (!char.IsWhiteSpace(c))
				{
					stringBuilder.Append(c);
				}
			}
			return (T)ParseValue(typeof(T), stringBuilder.ToString());
		}

		private static int AppendUntilStringEnd(bool appendEscapeCharacter, int startIdx, string json)
		{
			stringBuilder.Append(json[startIdx]);
			for (int i = startIdx + 1; i < json.Length; i++)
			{
				if (json[i] == '\\')
				{
					if (appendEscapeCharacter)
					{
						stringBuilder.Append(json[i]);
					}
					stringBuilder.Append(json[i + 1]);
					i++;
				}
				else
				{
					if (json[i] == '"')
					{
						stringBuilder.Append(json[i]);
						return i;
					}
					stringBuilder.Append(json[i]);
				}
			}
			return json.Length - 1;
		}

		private static List<string> Split(string json)
		{
			List<string> list = ((splitArrayPool.Count > 0) ? splitArrayPool.Pop() : new List<string>());
			list.Clear();
			if (json.Length == 2)
			{
				return list;
			}
			int num = 0;
			stringBuilder.Length = 0;
			for (int i = 1; i < json.Length - 1; i++)
			{
				switch (json[i])
				{
				case '[':
				case '{':
					num++;
					break;
				case ']':
				case '}':
					num--;
					break;
				case '"':
					i = AppendUntilStringEnd(appendEscapeCharacter: true, i, json);
					continue;
				case ',':
				case ':':
					if (num == 0)
					{
						list.Add(stringBuilder.ToString());
						stringBuilder.Length = 0;
						continue;
					}
					break;
				}
				stringBuilder.Append(json[i]);
			}
			list.Add(stringBuilder.ToString());
			return list;
		}

		internal static object ParseValue(Type type, string json)
		{
			if (type == typeof(string))
			{
				if (json.Length <= 2)
				{
					return string.Empty;
				}
				StringBuilder stringBuilder = new StringBuilder(json.Length);
				for (int i = 1; i < json.Length - 1; i++)
				{
					if (json[i] == '\\' && i + 1 < json.Length - 1)
					{
						int num = "\"\\nrtbf/".IndexOf(json[i + 1]);
						if (num >= 0)
						{
							stringBuilder.Append("\"\\\n\r\t\b\f/"[num]);
							i++;
							continue;
						}
						if (json[i + 1] == 'u' && i + 5 < json.Length - 1)
						{
							uint result = 0u;
							if (uint.TryParse(json.Substring(i + 2, 4), NumberStyles.AllowHexSpecifier, null, out result))
							{
								stringBuilder.Append((char)result);
								i += 5;
								continue;
							}
						}
					}
					stringBuilder.Append(json[i]);
				}
				return stringBuilder.ToString();
			}
			if (type.IsPrimitive)
			{
				return Convert.ChangeType(json, type, CultureInfo.InvariantCulture);
			}
			if (type == typeof(decimal))
			{
				decimal.TryParse(json, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2);
				return result2;
			}
			if (type == typeof(DateTime))
			{
				DateTime.TryParse(json.Replace("\"", ""), CultureInfo.InvariantCulture, DateTimeStyles.None, out var result3);
				return result3;
			}
			if (json == "null")
			{
				return null;
			}
			if (type.IsEnum)
			{
				if (json[0] == '"')
				{
					json = json.Substring(1, json.Length - 2);
				}
				try
				{
					return Enum.Parse(type, json, ignoreCase: false);
				}
				catch
				{
					return 0;
				}
			}
			if (type.IsArray)
			{
				Type elementType = type.GetElementType();
				if (json[0] != '[' || json[json.Length - 1] != ']')
				{
					return null;
				}
				List<string> list = Split(json);
				Array array = Array.CreateInstance(elementType, list.Count);
				for (int j = 0; j < list.Count; j++)
				{
					array.SetValue(ParseValue(elementType, list[j]), j);
				}
				splitArrayPool.Push(list);
				return array;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
			{
				Type type2 = type.GetGenericArguments()[0];
				if (json[0] != '[' || json[json.Length - 1] != ']')
				{
					return null;
				}
				List<string> list2 = Split(json);
				IList list3 = (IList)type.GetConstructor(new Type[1] { typeof(int) }).Invoke(new object[1] { list2.Count });
				for (int k = 0; k < list2.Count; k++)
				{
					list3.Add(ParseValue(type2, list2[k]));
				}
				splitArrayPool.Push(list2);
				return list3;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				Type[] genericArguments = type.GetGenericArguments();
				Type type3 = genericArguments[0];
				Type type4 = genericArguments[1];
				if (type3 != typeof(string))
				{
					return null;
				}
				if (json[0] != '{' || json[json.Length - 1] != '}')
				{
					return null;
				}
				List<string> list4 = Split(json);
				if (list4.Count % 2 != 0)
				{
					return null;
				}
				IDictionary dictionary = (IDictionary)type.GetConstructor(new Type[1] { typeof(int) }).Invoke(new object[1] { list4.Count / 2 });
				for (int l = 0; l < list4.Count; l += 2)
				{
					if (list4[l].Length > 2)
					{
						string key = list4[l].Substring(1, list4[l].Length - 2);
						object value = ParseValue(type4, list4[l + 1]);
						dictionary[key] = value;
					}
				}
				return dictionary;
			}
			if (type == typeof(object))
			{
				return ParseAnonymousValue(json);
			}
			if (json[0] == '{' && json[json.Length - 1] == '}')
			{
				return ParseObject(type, json);
			}
			return null;
		}

		private static object ParseAnonymousValue(string json)
		{
			if (json.Length == 0)
			{
				return null;
			}
			if (json[0] == '{' && json[json.Length - 1] == '}')
			{
				List<string> list = Split(json);
				if (list.Count % 2 != 0)
				{
					return null;
				}
				Dictionary<string, object> dictionary = new Dictionary<string, object>(list.Count / 2);
				for (int i = 0; i < list.Count; i += 2)
				{
					dictionary[list[i].Substring(1, list[i].Length - 2)] = ParseAnonymousValue(list[i + 1]);
				}
				return dictionary;
			}
			if (json[0] == '[' && json[json.Length - 1] == ']')
			{
				List<string> list2 = Split(json);
				List<object> list3 = new List<object>(list2.Count);
				for (int j = 0; j < list2.Count; j++)
				{
					list3.Add(ParseAnonymousValue(list2[j]));
				}
				return list3;
			}
			if (json[0] == '"' && json[json.Length - 1] == '"')
			{
				string text = json.Substring(1, json.Length - 2);
				return text.Replace("\\", string.Empty);
			}
			if (char.IsDigit(json[0]) || json[0] == '-')
			{
				if (json.Contains("."))
				{
					double.TryParse(json, NumberStyles.Float, CultureInfo.InvariantCulture, out var result);
					return result;
				}
				int.TryParse(json, out var result2);
				return result2;
			}
			if (json == "true")
			{
				return true;
			}
			if (json == "false")
			{
				return false;
			}
			return null;
		}

		private static Dictionary<string, T> CreateMemberNameDictionary<T>(T[] members) where T : MemberInfo
		{
			Dictionary<string, T> dictionary = new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase);
			foreach (T val in members)
			{
				if (val.IsDefined(typeof(IgnoreDataMemberAttribute), inherit: true))
				{
					continue;
				}
				string name = val.Name;
				if (val.IsDefined(typeof(DataMemberAttribute), inherit: true))
				{
					DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)Attribute.GetCustomAttribute(val, typeof(DataMemberAttribute), inherit: true);
					if (!string.IsNullOrEmpty(dataMemberAttribute.Name))
					{
						name = dataMemberAttribute.Name;
					}
				}
				dictionary.Add(name, val);
			}
			return dictionary;
		}

		private static object ParseObject(Type type, string json)
		{
			object uninitializedObject = FormatterServices.GetUninitializedObject(type);
			List<string> list = Split(json);
			if (list.Count % 2 != 0)
			{
				return uninitializedObject;
			}
			if (!fieldInfoCache.TryGetValue(type, out var value))
			{
				value = CreateMemberNameDictionary(type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
				fieldInfoCache.Add(type, value);
			}
			if (!propertyInfoCache.TryGetValue(type, out var value2))
			{
				value2 = CreateMemberNameDictionary(type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
				propertyInfoCache.Add(type, value2);
			}
			for (int i = 0; i < list.Count; i += 2)
			{
				if (list[i].Length > 2)
				{
					string key = list[i].Substring(1, list[i].Length - 2);
					string json2 = list[i + 1];
					PropertyInfo value4;
					if (value.TryGetValue(key, out var value3))
					{
						value3.SetValue(uninitializedObject, ParseValue(value3.FieldType, json2));
					}
					else if (value2.TryGetValue(key, out value4))
					{
						value4.SetValue(uninitializedObject, ParseValue(value4.PropertyType, json2), null);
					}
				}
			}
			return uninitializedObject;
		}
	}
	public static class JSONWriter
	{
		public static string ToJson(this object item)
		{
			StringBuilder stringBuilder = new StringBuilder();
			AppendValue(stringBuilder, item);
			return stringBuilder.ToString();
		}

		private static void AppendValue(StringBuilder stringBuilder, object item)
		{
			if (item == null)
			{
				stringBuilder.Append("null");
				return;
			}
			Type type = item.GetType();
			if (type == typeof(string) || type == typeof(char))
			{
				stringBuilder.Append('"');
				string text = item.ToString();
				for (int i = 0; i < text.Length; i++)
				{
					if (text[i] < ' ' || text[i] == '"' || text[i] == '\\')
					{
						stringBuilder.Append('\\');
						int num = "\"\\\n\r\t\b\f".IndexOf(text[i]);
						if (num >= 0)
						{
							stringBuilder.Append("\"\\nrtbf"[num]);
						}
						else
						{
							stringBuilder.AppendFormat("u{0:X4}", (uint)text[i]);
						}
					}
					else
					{
						stringBuilder.Append(text[i]);
					}
				}
				stringBuilder.Append('"');
				return;
			}
			if (type == typeof(byte) || type == typeof(sbyte))
			{
				stringBuilder.Append(item.ToString());
				return;
			}
			if (type == typeof(short) || type == typeof(ushort))
			{
				stringBuilder.Append(item.ToString());
				return;
			}
			if (type == typeof(int) || type == typeof(uint))
			{
				stringBuilder.Append(item.ToString());
				return;
			}
			if (type == typeof(long) || type == typeof(ulong))
			{
				stringBuilder.Append(item.ToString());
				return;
			}
			if (type == typeof(float))
			{
				stringBuilder.Append(((float)item).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(double))
			{
				stringBuilder.Append(((double)item).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(decimal))
			{
				stringBuilder.Append(((decimal)item).ToString(CultureInfo.InvariantCulture));
				return;
			}
			if (type == typeof(bool))
			{
				stringBuilder.Append(((bool)item) ? "true" : "false");
				return;
			}
			if (type == typeof(DateTime))
			{
				stringBuilder.Append('"');
				stringBuilder.Append(((DateTime)item).ToString(CultureInfo.InvariantCulture));
				stringBuilder.Append('"');
				return;
			}
			if (type.IsEnum)
			{
				stringBuilder.Append('"');
				stringBuilder.Append(item.ToString());
				stringBuilder.Append('"');
				return;
			}
			if (item is IList)
			{
				stringBuilder.Append('[');
				bool flag = true;
				IList list = item as IList;
				for (int j = 0; j < list.Count; j++)
				{
					if (flag)
					{
						flag = false;
					}
					else
					{
						stringBuilder.Append(',');
					}
					AppendValue(stringBuilder, list[j]);
				}
				stringBuilder.Append(']');
				return;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				Type type2 = type.GetGenericArguments()[0];
				if (type2 != typeof(string))
				{
					stringBuilder.Append("{}");
					return;
				}
				stringBuilder.Append('{');
				IDictionary dictionary = item as IDictionary;
				bool flag2 = true;
				foreach (object key in dictionary.Keys)
				{
					if (flag2)
					{
						flag2 = false;
					}
					else
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append('"');
					stringBuilder.Append((string)key);
					stringBuilder.Append("\":");
					AppendValue(stringBuilder, dictionary[key]);
				}
				stringBuilder.Append('}');
				return;
			}
			stringBuilder.Append('{');
			bool flag3 = true;
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			for (int k = 0; k < fields.Length; k++)
			{
				if (fields[k].IsDefined(typeof(IgnoreDataMemberAttribute), inherit: true))
				{
					continue;
				}
				object value = fields[k].GetValue(item);
				if (value != null)
				{
					if (flag3)
					{
						flag3 = false;
					}
					else
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append('"');
					stringBuilder.Append(GetMemberName(fields[k]));
					stringBuilder.Append("\":");
					AppendValue(stringBuilder, value);
				}
			}
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			for (int l = 0; l < properties.Length; l++)
			{
				if (!properties[l].CanRead || properties[l].IsDefined(typeof(IgnoreDataMemberAttribute), inherit: true))
				{
					continue;
				}
				object value2 = properties[l].GetValue(item, null);
				if (value2 != null)
				{
					if (flag3)
					{
						flag3 = false;
					}
					else
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append('"');
					stringBuilder.Append(GetMemberName(properties[l]));
					stringBuilder.Append("\":");
					AppendValue(stringBuilder, value2);
				}
			}
			stringBuilder.Append('}');
		}

		private static string GetMemberName(MemberInfo member)
		{
			if (member.IsDefined(typeof(DataMemberAttribute), inherit: true))
			{
				DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)Attribute.GetCustomAttribute(member, typeof(DataMemberAttribute), inherit: true);
				if (!string.IsNullOrEmpty(dataMemberAttribute.Name))
				{
					return dataMemberAttribute.Name;
				}
			}
			return member.Name;
		}
	}
}
namespace WildfrostModMiya
{
	public static class CardAdder
	{
		public enum VanillaStatusEffects
		{
			None,
			AddAttackAndHealthToSummon,
			Block,
			Bombard1,
			Bombard2,
			BonusDamageEqualToDartsInHand,
			BonusDamageEqualToGoldFactor002,
			BonusDamageEqualToJuice,
			BonusDamageEqualToScrapOnBoard,
			BonusDamageEqualToScrap,
			BonusDamageEqualToShell,
			BoostEffects,
			Budge,
			CannotRecall,
			CheckHasJuice,
			Cleanse,
			CombineWhen2Deployed,
			CopyEffects,
			Crush,
			DamageEqualToHealth,
			DamageToFrontAllies,
			Demonize,
			DestroyAfterUse,
			DestroySelfAfterTurn,
			DoubleAllSpiceWhenDestroyed,
			DoubleBlock,
			DoubleInk,
			DoubleJuice,
			DoubleNegativeEffects,
			DoubleOverload,
			DoubleShell,
			DoubleShroom,
			DoubleSpice,
			DoubleVim,
			DrawCards,
			EatHealthAndAttack,
			EatHealthAndAttackAndEffects,
			EatAlliesInRowHealthAndAttack,
			EatRandomAllyHealthAndAttackAndEffects,
			Escape,
			FillBoardFinalBoss,
			FinalBossPhase2,
			Flee,
			FreeAction,
			FrenzyBossPhase2,
			Frost,
			GainFrenzyWhenWildUnitKilled,
			GainGold,
			GoatWampusPhase2,
			HaltSpice,
			Haze,
			HealNoPing,
			HealFrontAllyBasedOnDamageDealt,
			HealFullAndGainEqualSpice,
			HealToFrontAllies,
			Heal,
			HighPriorityPosition,
			HitAllCrownEnemies,
			HitAllEnemiesInRow,
			HitAllEnemies,
			HitAllUndamagedEnemies,
			HitFurthestTarget,
			HitRandomTarget,
			ImmuneToFrost,
			ImmuneToSnow,
			ImmuneToSpice,
			ImmuneToVim,
			IncreaseAllSpiceAppliedNoDesc,
			IncreaseAttackAndHealth,
			IncreaseAttackAndLoseHalfHealth,
			IncreaseAttackEffect1,
			IncreaseAttackWhileAlone,
			IncreaseAttackWhileDamaged,
			IncreaseAttack,
			IncreaseEffects,
			IncreaseMaxCounter,
			IncreaseMaxHealth,
			Injury,
			InstantAddScrap,
			InstantApplyAttackToApplier,
			InstantApplyCurrentAttackToAllies,
			InstantApplyCurrentAttackToRandomAlly,
			InstantApplyFrenzyToItemInHand,
			InstantDraw,
			InstantGainAimless,
			InstantGainFury,
			InstantGainNoomlinToCardInHand,
			InstantGainSoulboundToEnemy,
			InstantSummonBloo,
			InstantSummonCopyOfItem,
			InstantSummonCopyOnOtherSideWithXHealth,
			InstantSummonCopy,
			InstantSummonDregg,
			InstantSummonFallow,
			InstantSummonGearhammerInHand,
			InstantSummonJunkInHand,
			InstantSummonSunShardInHand,
			InstantSummonTailsFour,
			InstantSummonTailsOne,
			InstantSummonTailsThree,
			InstantSummonTailsTwo,
			Kill,
			LastStand,
			LoseHalfHealth,
			LoseJuice,
			LoseScrap,
			LowPriorityPosition,
			Lumin,
			MultiHitTemporaryAndNotVisible,
			MultiHit,
			MustHaveJuiceToTrigger,
			Null,
			OnCardPlayedAddFuryToTarget,
			OnCardPlayedAddGearhammerToHand,
			OnCardPlayedAddJunkToHand,
			OnCardPlayedAddScrapToRandomAlly,
			OnCardPlayedAddSoulboundToRandomAlly,
			OnCardPlayedAddSunShardToHand,
			OnCardPlayedApplyAttackToSelf,
			OnCardPlayedApplyBlockToRandomUnit,
			OnCardPlayedApplyFrostToRandomEnemy,
			OnCardPlayedApplyHazeToRandomEnemy,
			OnCardPlayedApplyInkToRandomEnemy,
			OnCardPlayedApplyOverloadToFrontEnemy,
			OnCardPlayedApplyShellToRandomAlly,
			OnCardPlayedApplyShroomToEnemies,
			OnCardPlayedApplySnowToEnemiesInRow,
			OnCardPlayedApplySpiceToRandomAlly,
			OnCardPlayedApplyTeethToRandomAlly,
			OnCardPlayedBoostToRandomAlly,
			OnCardPlayedBoostToRandomEnemy,
			OnCardPlayedDamageFrostedEnemies,
			OnCardPlayedDamageInkedEnemies,
			OnCardPlayedDamageToSelfAndAlliesInRow,
			OnCardPlayedDamageUndamagedEnemies,
			OnCardPlayedDestroyRandomCardInHand,
			OnCardPlayedDestroyRandomJunkInHand,
			OnCardPlayedDestroyRightmostCardInHand,
			OnCardPlayedDoubleVimToSelf,
			OnCardPlayedLose1JuiceToSelfNoDesc,
			OnCardPlayedLoseScrapToSelf,
			OnCardPlayedReduceAttackEffect1ToSelf,
			OnCardPlayedReduceCounterToAllies,
			OnCardPlayedSacrificeRandomAlly,
			OnCardPlayedTakeHealthFromAllies,
			OnCardPlayedTriggerAgainstAllyBehind,
			OnCardPlayedTriggerRandomAlly,
			OnCardPlayedUseRandomItemInHandAgainstRandomEnemy,
			OnCardPlayedVimToAllies,
			OnCardPlayedVimToSelf,
			OnCardPlayedVoidToEnemies,
			OnHitDamageDamagedTarget,
			OnHitDamageFrostedTarget,
			OnHitDamageShelledTarget,
			OnHitDamageSnowedTarget,
			OnHitEqualDamageToInkedTarget,
			OnHitEqualHealToFrontAlly,
			OnHitEqualOverloadToTarget,
			OnHitEqualSnowToTarget,
			OnHitPullTarget,
			OnHitPushTarget,
			OnKillApplyAttackToSelf,
			OnKillApplyBlockToSelf,
			OnKillApplyGoldToSelf,
			OnKillApplyScrapToAllies,
			OnKillApplyScrapToAllyBehind,
			OnKillApplyScrapToRandomAlly,
			OnKillApplyShellToSelf,
			OnKillApplyStealthToSelf,
			OnKillApplyTeethToSelf,
			OnKillApplyVimToAllyBehind,
			OnKillApplyVimToRandomAlly,
			OnKillApplyVimToRandomEnemy,
			OnKillDraw,
			OnKillHealToSelfAndAlliesInRow,
			OnKillHealToSelf,
			OnKillIncreaseHealthToSelfAndAllies,
			OnTurnApplyAttackToSelf,
			OnTurnApplyDemonizeToRandomEnemy,
			OnTurnApplyInkToEnemies,
			OnTurnApplyInkToRandomEnemy,
			OnTurnApplyJuiceToAllyBehind,
			OnTurnApplyOverloadToRandomEnemy,
			OnTurnApplyScrapToAllyAhead,
			OnTurnApplyScrapToAllyBehind,
			OnTurnApplyScrapToRandomAlly,
			OnTurnApplyScrapToSelf,
			OnTurnApplyShellToAllies,
			OnTurnApplyShellToAllyInFrontOf,
			OnTurnApplyShellToSelf,
			OnTurnApplySnowToEnemies,
			OnTurnApplySpiceToAllies,
			OnTurnApplySpiceToAllyBehind,
			OnTurnApplySpiceToAllyInFrontOf,
			OnTurnApplyTeethToSelf,
			OnTurnApplyVimToAllyBehind,
			OnTurnApplyVimToRandomAlly,
			OnTurnApplyVoidToEveryone,
			OnTurnApplyVoidToRandomEnemy,
			OnTurnEatRandomAllyHealthAndAttackAndEffects,
			OnTurnEscapeToSelf,
			OnTurnHealAllies,
			OngoingIncreaseAttack,
			OngoingIncreaseEffectFactor,
			OngoingIncreaseEffects,
			OngoingReduceAttack,
			Overload,
			PreTriggerGainTempMultiHitEqualToJuice1,
			PreTriggerGainTempMultiHitEqualToScrap1,
			PreTurnDestroyAllItemsInHand,
			PreTurnDestroyRandomCardInHand,
			PreTurnEatAlliesInRowHealthAndAttack,
			PreTurnEatRandomAllyHealthAndAttackAndEffects,
			PreTurnGainAttackForEachItemInHandForEachCardDestroyed,
			PreTurnGainTempMultiHitEqualToJuice,
			PreTurnTakeJuiceFromRandomAlly,
			PreTurnTakeScrapFromRandomAlly,
			Pull,
			Push,
			RecycleJunk,
			RedrawCards,
			ReduceAttackEffect1,
			ReduceAttack,
			ReduceCounter,
			ReduceEffects,
			ReduceMaxCounter,
			ReduceMaxHealthMustbeally,
			ReduceMaxHealth,
			ResistShroom,
			ResistSnow,
			ResistSpice,
			SacrificeAlly,
			SacrificeCardInHand,
			SacrificeEnemy,
			Scrap,
			SetHealth,
			SetMaxHealth,
			Shell,
			Shroom,
			Snow,
			SoulboundBossPhase2,
			Spice,
			Split,
			SplitBossPhase2,
			Stealth,
			SummonBeepop,
			SummonBloo,
			SummonBoBo,
			SummonBonzo,
			SummonDregg,
			SummonEnemyLeech,
			SummonEnemyPigeon,
			SummonEnemyPopper,
			SummonFallow,
			SummonGearhammer,
			SummonItem,
			SummonJunk,
			SummonPlep,
			SummonSunShard,
			SummonTailsFive,
			SummonTailsFour,
			SummonTailsOne,
			SummonTailsThree,
			SummonTailsTwo,
			SummonTigris,
			SummonUzu,
			Summoned,
			Take100DamageWhenSoulboundUnitKilled,
			TakeHealth,
			Teeth,
			TemporaryAimless,
			TemporaryBarrage,
			TemporaryFury,
			TemporaryNoomlin,
			TemporaryPigheaded,
			TemporarySoulbound,
			TemporarySummoned,
			TemporaryUnbreakable,
			TemporaryUnmovable,
			TriggerAgainstAndReduceUses,
			TriggerAgainstDontCountAsTrigger,
			TriggerAgainstAllyWhenAllyIsHit,
			TriggerAgainstAttackerWhenHit,
			TriggerAgainstCrownAlliesWhenDiscarded,
			TriggerAgainstCrownAlliesWhenDrawn,
			TriggerAgainstRandomAllyWhenDiscarded,
			TriggerAgainstRandomAllyWhenDrawn,
			TriggerAgainstRandomEnemy,
			TriggerAgainstRandomUnitWhenDiscarded,
			TriggerAgainstRandomUnitWhenDrawn,
			TriggerAgainstWhenAllyAttacks,
			TriggerAgainstWhenFrostApplied,
			TriggerAgainstWhenSnowApplied,
			TriggerAgainstWhenWeaknessApplied,
			TriggerAgainst,
			TriggerWhenAllyAttacks,
			TriggerWhenAllyInRowAttacks,
			TriggerWhenAllyIsHit,
			TriggerWhenDeployed,
			TriggerWhenEnemyIsKilled,
			TriggerWhenJunkDestroyed,
			TriggerWhenRedrawHit,
			Trigger,
			Unmovable,
			Weakness,
			WhenAllyIsHealedApplyEqualSpice,
			WhenAllyIsHealedTriggerToSelf,
			WhenAllyisHitApplyFrostToAttacker,
			WhenAllyisHitApplyShroomToAttacker,
			WhenAllyisHitApplyTeethToSelf,
			WhenAllyisHitApplyVimToTarget,
			WhenAllyisHitHealToTarget,
			WhenAllyisHitIncreaseHealthToSelf,
			WhenAllyIsKilledApplyAttackToSelf,
			WhenAllyIsKilledGainTheirAttack,
			WhenAllyIsKilledLoseHalfHealthAndGainAttack,
			WhenAllyIsKilledTriggerToSelf,
			WhenAllyIsSacrificedGainTheirAttack,
			WhenAllyIsSacrificedTriggerToSelf,
			WhenAnyoneTakesShroomDamageApplyAttackToSelf,
			WhenBuiltAddJunkToHand,
			WhenBuiltApplyVimToSelf,
			WhenCardDestroyedAndGainAttack,
			WhenCardDestroyedAndGainJuice,
			WhenCardDestroyedAndReduceCounterToSelf,
			WhenConsumedAddHealthToAllies,
			WhenConsumedApplyOverloadToEnemies,
			WhenDeployedAddJunkToHand,
			WhenDeployedApplyBlockToSelf,
			WhenDeployedApplyFrenzyToSelf,
			WhenDeployedApplyInkToAllies,
			WhenDeployedApplyInkToEnemiesInRow,
			WhenDeployedCopyEffectsOfRandomEnemy,
			WhenDeployedFillBoardFinalBoss,
			WhenDeployedSummonWowee,
			WhenDestroyedApplyDamageToAlliesInRow,
			WhenDestroyedApplyDamageToAttacker,
			WhenDestroyedApplyDamageToEnemiesEqualToJuice,
			WhenDestroyedApplyDamageToEnemiesInRow,
			WhenDestroyedApplyFrenzyToRandomAlly,
			WhenDestroyedApplyHazeToAttacker,
			WhenDestroyedApplyOverloadToAttacker,
			WhenDestroyedApplySpiceToAllies,
			WhenDestroyedApplyStealthToAlliesInRow,
			WhenDestroyedSummonDregg,
			WhenDestroyedTriggerToAllies,
			WhenDrawnApplySnowToAllies,
			WhenEnemiesAttackApplyDemonizeToAttacker,
			WhenEnemyShroomedIsKilledApplyTheirShroomToRandomEnemy,
			WhenEnemyDeployedCopyEffectsOfTarget,
			WhenEnemyIsKilledApplyGoldToSelf,
			WhenEnemyIsKilledApplyShellToAttacker,
			WhenHealedApplyAttackToSelf,
			WhenHealedTriggerToSelf,
			WhenHealthLostApplyEqualAttackToSelfAndAllies,
			WhenHealthLostApplyEqualFrostToSelf,
			WhenHealthLostApplyEqualSpiceToSelf,
			WhenHitAddFrenzyToSelf,
			WhenHitAddGearhammerToHand,
			WhenHitAddHealthLostToAttacker,
			WhenHitAddHealthLostToRandomAlly,
			WhenHitAddJunkToHand,
			WhenHitApplyBlockToRandomAlly,
			WhenHitApplyDemonizeToAttacker,
			WhenHitApplyFrostToEnemies,
			WhenHitApplyFrostToRandomEnemy,
			WhenHitApplyGoldToAttackerNoPing,
			WhenHitApplyInkToAttacker,
			WhenHitApplyInkToRandomEnemy,
			WhenHitApplyInkToSelf,
			WhenHitApplyOverloadToAttacker,
			WhenHitApplyShellToAllies,
			WhenHitApplyShellToAllyBehind,
			WhenHitApplyShellToSelf,
			WhenHitApplyShroomToAttacker,
			WhenHitApplyShroomToRandomEnemy,
			WhenHitApplySnowToAttacker,
			WhenHitApplySnowToEnemies,
			WhenHitApplySnowToRandomEnemy,
			WhenHitApplySpiceToAlliesAndEnemiesAndSelf,
			WhenHitApplySpiceToAllies,
			WhenHitApplySpiceToAlliesInRow,
			WhenHitApplySpiceToSelf,
			WhenHitApplyStealthToSelf,
			WhenHitApplyVimToSelf,
			WhenHitApplyVoidToAttacker,
			WhenHitApplyWeaknessToAttacker,
			WhenHitDamageToEnemies,
			WhenHitDamageToEnemiesInRow,
			WhenHitDraw,
			WhenHitEqualDamageToAttacker,
			WhenHitGainAttackToSelfNoPing,
			WhenHitGainTeethToSelf,
			WhenHitIncreaseAttackEffect1ToSelf,
			WhenHitIncreaseAttackToRandomAlly,
			WhenHitIncreaseHealthToRandomAlly,
			WhenHitReduceAttackToAttacker,
			WhenHitReduceAttackToSelf,
			WhenHitReduceCounterToSelf,
			WhenHitTriggerToSelf,
			WhenHitWithJunkAddFrenzyToSelf,
			WhenJuiceAppliedToSelfGainFrenzy,
			WhenSacrificedSummonTailsFour,
			WhenSacrificedSummonTailsOne,
			WhenSacrificedSummonTailsThree,
			WhenSacrificedSummonTailsTwo,
			WhenShellAppliedToSelfGainSpiceInstead,
			WhenShroomAppliedToAnythingDoubleAmountAndLoseScrap,
			WhenShroomDamageTakenTriggerToSelf,
			WhenSnowAppliedToAnythingGainAttackToSelf,
			WhenSnowAppliedToAnythingGainEqualAttackToSelf,
			WhenSnowAppliedToSelfApplyDemonizeToEnemies,
			WhenSnowAppliedToSelfGainEqualAttack,
			WhenSpiceXAppliedToSelfTriggerToSelf,
			WhenVimAppliedToAnythingDoubleAmount,
			WhenXHealthLostSplit,
			WhileActiveAddEqualAttackToJunkInHand,
			WhileActiveAimlessToEnemies,
			WhileActiveBarrageToAllies,
			WhileActiveBarrageToAlliesInRow,
			WhileActiveBarrageToEnemies,
			WhileActiveFrenzyToAllies,
			WhileActiveFrenzyToCrownAllies,
			WhileActiveHaltSpiceToAllies,
			WhileActiveIncreaseAllSpiceApplied,
			WhileActiveIncreaseAttackbyCurrentToAllies,
			WhileActiveIncreaseAttackbyCurrentToSummonedAllies,
			WhileActiveIncreaseAttackToAlliesAndEnemies,
			WhileActiveIncreaseAttackToAlliesNoDesc,
			WhileActiveIncreaseAttackToAllies,
			WhileActiveIncreaseAttackToAlliesInRow,
			WhileActiveIncreaseAttackToItemsInHand,
			WhileActiveIncreaseAttackToJunkInHand,
			WhileActiveIncreaseEffectsToAlliesAndEnemies,
			WhileActiveIncreaseEffectsToFrontAlly,
			WhileActiveIncreaseEffectsToHand,
			WhileActivePigheadedToEnemies,
			WhileActiveReduceAttackToEnemiesNoPingAndNoDesc,
			WhileActiveSnowImmuneToAllies,
			WhileActiveTeethToAllies,
			WhileActiveUnmovableToEnemies,
			WhileInHandReduceAttackToAllies,
			WhileLastInHandDoubleEffectsToSelf
		}

		public enum VanillaTraits
		{
			None,
			Aimless,
			Backline,
			Barrage,
			Bombard1,
			Bombard2,
			Combo,
			Consume,
			Crush,
			Draw,
			Effigy,
			Explode,
			Frontline,
			Fury,
			Greed,
			Hellbent,
			Knockback,
			Longshot,
			Noomlin,
			Pigheaded,
			Pull,
			Recycle,
			Smackback,
			Soulbound,
			Spark,
			Summoned,
			Trash,
			Unmovable,
			Wild
		}

		public enum VanillaRewardPools
		{
			None,
			BasicItemPool,
			BasicUnitPool,
			BasicCharmPool,
			GeneralItemPool,
			GeneralUnitPool,
			GeneralCharmPool,
			MagicItemPool,
			MagicUnitPool,
			MagicCharmPool,
			ClunkItemPool,
			ClunkUnitPool,
			ClunkCharmPool
		}

		public enum VanillaCardAnimationProfiles
		{
			None,
			HeartbeatAnimationProfile,
			FloatAnimationProfile,
			FloatSquishAnimationProfile,
			FlyAnimationProfile,
			GiantAnimationProfile,
			HangAnimationProfile,
			Heartbeat2AnimationProfile,
			PingAnimationProfile,
			PulseAnimationProfile,
			ShakeAnimationProfile,
			SquishAnimationProfile,
			SwayAnimationProfile,
			GoopAnimationProfile
		}

		public enum VanillaBloodProfiles
		{
			None,
			BloodProfileBerry,
			BloodProfileBlack,
			BloodProfileBlueDouble,
			BloodProfileFungus,
			BloodProfileNormal,
			BloodProfileSnow,
			BloodProfilePinkWisp,
			BloodProfileHusk
		}

		public enum VanillaTargetModes
		{
			None,
			TargetModeAll,
			TargetModeAllUndamaged,
			TargetModeBack,
			TargetModeBasic,
			TargetModeRandom,
			TargetModeRow,
			TargetModeCrowns
		}

		public enum VanillaCardUpgrades
		{
			None,
			CardUpgradeAcorn,
			CardUpgradeAttackAndHealth,
			CardUpgradeAttackConsume,
			CardUpgradeAttackIncreaseCounter,
			CardUpgradeAttackRemoveEffects,
			CardUpgradeBalanced,
			CardUpgradeBarrage,
			CardUpgradeBattle,
			CardUpgradeBling,
			CardUpgradeBlock,
			CardUpgradeBom,
			CardUpgradeBombskull,
			CardUpgradeBoost,
			CardUpgradeCake,
			CardUpgradeCloudberry,
			CardUpgradeConsume,
			CardUpgradeConsumeAddHealth,
			CardUpgradeConsumeOverload,
			CardUpgradeCritical,
			CardUpgradeCrush,
			CardUpgradeDemonize,
			CardUpgradeDraw,
			CardUpgradeEffigy,
			CardUpgradeFrenzyConsume,
			CardUpgradeFrenzyReduceAttack,
			CardUpgradeFrosthand,
			CardUpgradeFury,
			CardUpgradeGreed,
			CardUpgradeHeart,
			CardUpgradeHook,
			CardUpgradeInk,
			CardUpgradeNoomlin,
			CardUpgradeOverload,
			CardUpgradePig,
			CardUpgradePunchfist,
			CardUpgradeRemoveCharmLimit,
			CardUpgradeScrap,
			CardUpgradeShellBecomesSpice,
			CardUpgradeShellOnKill,
			CardUpgradeShroom,
			CardUpgradeShroomReduceHealth,
			CardUpgradeSnowball,
			CardUpgradeSnowImmune,
			CardUpgradeSpark,
			CardUpgradeSpice,
			CardUpgradeSpiky,
			CardUpgradeSun,
			CardUpgradeTeethWhenHit,
			CardUpgradeTrash,
			CardUpgradeWeakness,
			CardUpgradeWildcard,
			Crown
		}

		public enum VanillaCardTypes
		{
			None,
			Boss,
			BossSmall,
			Clunker,
			Enemy,
			Friendly,
			Item,
			Leader,
			Miniboss,
			Summoned
		}

		[Flags]
		public enum CanPlay
		{
			None = 0,
			CanPlayOnBoard = 1,
			CanPlayOnEnemy = 2,
			CanPlayOnFriendly = 4,
			CanPlayOnHand = 8
		}

		public static readonly Dictionary<VanillaStatusEffects, string> VanillaStatusEffectsNamesLookUp = new Dictionary<VanillaStatusEffects, string>
		{
			[VanillaStatusEffects.AddAttackAndHealthToSummon] = "Add Attack & Health To Summon",
			[VanillaStatusEffects.Block] = "Block",
			[VanillaStatusEffects.Bombard1] = "Bombard 1",
			[VanillaStatusEffects.Bombard2] = "Bombard 2",
			[VanillaStatusEffects.BonusDamageEqualToDartsInHand] = "Bonus Damage Equal To Darts In Hand",
			[VanillaStatusEffects.BonusDamageEqualToGoldFactor002] = "Bonus Damage Equal To Gold Factor 0.02",
			[VanillaStatusEffects.BonusDamageEqualToJuice] = "Bonus Damage Equal To Juice",
			[VanillaStatusEffects.BonusDamageEqualToScrapOnBoard] = "Bonus Damage Equal To Scrap On Board",
			[VanillaStatusEffects.BonusDamageEqualToScrap] = "Bonus Damage Equal To Scrap",
			[VanillaStatusEffects.BonusDamageEqualToShell] = "Bonus Damage Equal To Shell",
			[VanillaStatusEffects.BoostEffects] = "Boost Effects",
			[VanillaStatusEffects.Budge] = "Budge",
			[VanillaStatusEffects.CannotRecall] = "Cannot Recall",
			[VanillaStatusEffects.CheckHasJuice] = "Check Has Juice",
			[VanillaStatusEffects.Cleanse] = "Cleanse",
			[VanillaStatusEffects.CombineWhen2Deployed] = "Combine When 2 Deployed",
			[VanillaStatusEffects.CopyEffects] = "Copy Effects",
			[VanillaStatusEffects.Crush] = "Crush",
			[VanillaStatusEffects.DamageEqualToHealth] = "Damage Equal To Health",
			[VanillaStatusEffects.DamageToFrontAllies] = "Damage To Front Allies",
			[VanillaStatusEffects.Demonize] = "Demonize",
			[VanillaStatusEffects.DestroyAfterUse] = "Destroy After Use",
			[VanillaStatusEffects.DestroySelfAfterTurn] = "Destroy Self After Turn",
			[VanillaStatusEffects.DoubleAllSpiceWhenDestroyed] = "Double All Spice When Destroyed",
			[VanillaStatusEffects.DoubleBlock] = "Double Block",
			[VanillaStatusEffects.DoubleInk] = "Double Ink",
			[VanillaStatusEffects.DoubleJuice] = "Double Juice",
			[VanillaStatusEffects.DoubleNegativeEffects] = "Double Negative Effects",
			[VanillaStatusEffects.DoubleOverload] = "Double Overload",
			[VanillaStatusEffects.DoubleShell] = "Double Shell",
			[VanillaStatusEffects.DoubleShroom] = "Double Shroom",
			[VanillaStatusEffects.DoubleSpice] = "Double Spice",
			[VanillaStatusEffects.DoubleVim] = "Double Vim",
			[VanillaStatusEffects.DrawCards] = "Draw Cards",
			[VanillaStatusEffects.EatHealthAndAttack] = "Eat (Health & Attack)",
			[VanillaStatusEffects.EatHealthAndAttackAndEffects] = "Eat (Health, Attack & Effects)",
			[VanillaStatusEffects.EatAlliesInRowHealthAndAttack] = "Eat Allies In Row (Health & Attack)",
			[VanillaStatusEffects.EatRandomAllyHealthAndAttackAndEffects] = "Eat Random Ally (Health, Attack & Effects)",
			[VanillaStatusEffects.Escape] = "Escape",
			[VanillaStatusEffects.FillBoardFinalBoss] = "Fill Board (Final Boss)",
			[VanillaStatusEffects.FinalBossPhase2] = "FinalBossPhase2",
			[VanillaStatusEffects.Flee] = "Flee",
			[VanillaStatusEffects.FreeAction] = "Free Action",
			[VanillaStatusEffects.FrenzyBossPhase2] = "FrenzyBossPhase2",
			[VanillaStatusEffects.Frost] = "Frost",
			[VanillaStatusEffects.GainFrenzyWhenWildUnitKilled] = "Gain Frenzy When Wild Unit Killed",
			[VanillaStatusEffects.GainGold] = "Gain Gold",
			[VanillaStatusEffects.GoatWampusPhase2] = "GoatWampusPhase2",
			[VanillaStatusEffects.HaltSpice] = "Halt Spice",
			[VanillaStatusEffects.Haze] = "Haze",
			[VanillaStatusEffects.HealNoPing] = "Heal (No Ping)",
			[VanillaStatusEffects.HealFrontAllyBasedOnDamageDealt] = "Heal Front Ally Based On Damage Dealt",
			[VanillaStatusEffects.HealFullAndGainEqualSpice] = "Heal Full, Gain Equal Spice",
			[VanillaStatusEffects.HealToFrontAllies] = "Heal To Front Allies",
			[VanillaStatusEffects.Heal] = "Heal",
			[VanillaStatusEffects.HighPriorityPosition] = "High Priority Position",
			[VanillaStatusEffects.HitAllCrownEnemies] = "Hit All Crown Enemies",
			[VanillaStatusEffects.HitAllEnemiesInRow] = "Hit All Enemies In Row",
			[VanillaStatusEffects.HitAllEnemies] = "Hit All Enemies",
			[VanillaStatusEffects.HitAllUndamagedEnemies] = "Hit All Undamaged Enemies",
			[VanillaStatusEffects.HitFurthestTarget] = "Hit Furthest Target",
			[VanillaStatusEffects.HitRandomTarget] = "Hit Random Target",
			[VanillaStatusEffects.ImmuneToFrost] = "ImmuneToFrost",
			[VanillaStatusEffects.ImmuneToSnow] = "ImmuneToSnow",
			[VanillaStatusEffects.ImmuneToSpice] = "ImmuneToSpice",
			[VanillaStatusEffects.ImmuneToVim] = "ImmuneToVim",
			[VanillaStatusEffects.IncreaseAllSpiceAppliedNoDesc] = "Increase All Spice Applied (No Desc)",
			[VanillaStatusEffects.IncreaseAttackAndHealth] = "Increase Attack & Health",
			[VanillaStatusEffects.IncreaseAttackAndLoseHalfHealth] = "Increase Attack & Lose Half Health",
			[VanillaStatusEffects.IncreaseAttackEffect1] = "Increase Attack Effect 1",
			[VanillaStatusEffects.IncreaseAttackWhileAlone] = "Increase Attack While Alone",
			[VanillaStatusEffects.IncreaseAttackWhileDamaged] = "Increase Attack While Damaged",
			[VanillaStatusEffects.IncreaseAttack] = "Increase Attack",
			[VanillaStatusEffects.IncreaseEffects] = "Increase Effects",
			[VanillaStatusEffects.IncreaseMaxCounter] = "Increase Max Counter",
			[VanillaStatusEffects.IncreaseMaxHealth] = "Increase Max Health",
			[VanillaStatusEffects.Injury] = "Injury",
			[VanillaStatusEffects.InstantAddScrap] = "Instant Add Scrap",
			[VanillaStatusEffects.InstantApplyAttackToApplier] = "Instant Apply Attack To Applier",
			[VanillaStatusEffects.InstantApplyCurrentAttackToAllies] = "Instant Apply Current Attack To Allies",
			[VanillaStatusEffects.InstantApplyCurrentAttackToRandomAlly] = "Instant Apply Current Attack To Random Ally",
			[VanillaStatusEffects.InstantApplyFrenzyToItemInHand] = "Instant Apply Frenzy (To Item In Hand)",
			[VanillaStatusEffects.InstantDraw] = "Instant Draw",
			[VanillaStatusEffects.InstantGainAimless] = "Instant Gain Aimless",
			[VanillaStatusEffects.InstantGainFury] = "Instant Gain Fury",
			[VanillaStatusEffects.InstantGainNoomlinToCardInHand] = "Instant Gain Noomlin (To Card In Hand)",
			[VanillaStatusEffects.InstantGainSoulboundToEnemy] = "Instant Gain Soulbound (To Enemy)",
			[VanillaStatusEffects.InstantSummonBloo] = "Instant Summon Bloo",
			[VanillaStatusEffects.InstantSummonCopyOfItem] = "Instant Summon Copy Of Item",
			[VanillaStatusEffects.InstantSummonCopyOnOtherSideWithXHealth] = "Instant Summon Copy On Other Side With X Health",
			[VanillaStatusEffects.InstantSummonCopy] = "Instant Summon Copy",
			[VanillaStatusEffects.InstantSummonDregg] = "Instant Summon Dregg",
			[VanillaStatusEffects.InstantSummonFallow] = "Instant Summon Fallow",
			[VanillaStatusEffects.InstantSummonGearhammerInHand] = "Instant Summon Gearhammer In Hand",
			[VanillaStatusEffects.InstantSummonJunkInHand] = "Instant Summon Junk In Hand",
			[VanillaStatusEffects.InstantSummonSunShardInHand] = "Instant Summon SunShard In Hand",
			[VanillaStatusEffects.InstantSummonTailsFour] = "Instant Summon TailsFour",
			[VanillaStatusEffects.InstantSummonTailsOne] = "Instant Summon TailsOne",
			[VanillaStatusEffects.InstantSummonTailsThree] = "Instant Summon TailsThree",
			[VanillaStatusEffects.InstantSummonTailsTwo] = "Instant Summon TailsTwo",
			[VanillaStatusEffects.Kill] = "Kill",
			[VanillaStatusEffects.LastStand] = "Last Stand",
			[VanillaStatusEffects.LoseHalfHealth] = "Lose Half Health",
			[VanillaStatusEffects.LoseJuice] = "Lose Juice",
			[VanillaStatusEffects.LoseScrap] = "Lose Scrap",
			[VanillaStatusEffects.LowPriorityPosition] = "Low Priority Position",
			[VanillaStatusEffects.Lumin] = "Lumin",
			[VanillaStatusEffects.MultiHitTemporaryAndNotVisible] = "MultiHit (Temporary, Not Visible)",
			[VanillaStatusEffects.MultiHit] = "MultiHit",
			[VanillaStatusEffects.MustHaveJuiceToTrigger] = "Must Have Juice To Trigger",
			[VanillaStatusEffects.Null] = "Null",
			[VanillaStatusEffects.OnCardPlayedAddFuryToTarget] = "On Card Played Add Fury To Target",
			[VanillaStatusEffects.OnCardPlayedAddGearhammerToHand] = "On Card Played Add Gearhammer To Hand",
			[VanillaStatusEffects.OnCardPlayedAddJunkToHand] = "On Card Played Add Junk To Hand",
			[VanillaStatusEffects.OnCardPlayedAddScrapToRandomAlly] = "On Card Played Add Scrap To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedAddSoulboundToRandomAlly] = "On Card Played Add Soulbound To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedAddSunShardToHand] = "On Card Played Add SunShard To Hand",
			[VanillaStatusEffects.OnCardPlayedApplyAttackToSelf] = "On Card Played Apply Attack To Self",
			[VanillaStatusEffects.OnCardPlayedApplyBlockToRandomUnit] = "On Card Played Apply Block To RandomUnit",
			[VanillaStatusEffects.OnCardPlayedApplyFrostToRandomEnemy] = "On Card Played Apply Frost To RandomEnemy",
			[VanillaStatusEffects.OnCardPlayedApplyHazeToRandomEnemy] = "On Card Played Apply Haze To RandomEnemy",
			[VanillaStatusEffects.OnCardPlayedApplyInkToRandomEnemy] = "On Card Played Apply Ink To RandomEnemy",
			[VanillaStatusEffects.OnCardPlayedApplyOverloadToFrontEnemy] = "On Card Played Apply Overload To FrontEnemy",
			[VanillaStatusEffects.OnCardPlayedApplyShellToRandomAlly] = "On Card Played Apply Shell To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedApplyShroomToEnemies] = "On Card Played Apply Shroom To Enemies",
			[VanillaStatusEffects.OnCardPlayedApplySnowToEnemiesInRow] = "On Card Played Apply Snow To EnemiesInRow",
			[VanillaStatusEffects.OnCardPlayedApplySpiceToRandomAlly] = "On Card Played Apply Spice To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedApplyTeethToRandomAlly] = "On Card Played Apply Teeth To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedBoostToRandomAlly] = "On Card Played Boost To RandomAlly",
			[VanillaStatusEffects.OnCardPlayedBoostToRandomEnemy] = "On Card Played Boost To RandomEnemy",
			[VanillaStatusEffects.OnCardPlayedDamageFrostedEnemies] = "On Card Played Damage Frosted Enemies",
			[VanillaStatusEffects.OnCardPlayedDamageInkedEnemies] = "On Card Played Damage Inked Enemies",
			[VanillaStatusEffects.OnCardPlayedDamageToSelfAndAlliesInRow] = "On Card Played Damage To Self & AlliesInRow",
			[VanillaStatusEffects.OnCardPlayedDamageUndamagedEnemies] = "On Card Played Damage Undamaged Enemies",
			[VanillaStatusEffects.OnCardPlayedDestroyRandomCardInHand] = "On Card Played Destroy Random Card In Hand",
			[VanillaStatusEffects.OnCardPlayedDestroyRandomJunkInHand] = "On Card Played Destroy Random Junk In Hand",
			[VanillaStatusEffects.OnCardPlayedDestroyRightmostCardInHand] = "On Card Played Destroy Rightmost Card In Hand",
			[VanillaStatusEffects.OnCardPlayedDoubleVimToSelf] = "On Card Played Double Vim To Self",
			[VanillaStatusEffects.OnCardPlayedLose1JuiceToSelfNoDesc] = "On Card Played Lose 1 Juice To Self (No Desc)",
			[VanillaStatusEffects.OnCardPlayedLoseScrapToSelf] = "On Card Played Lose Scrap To Self",
			[VanillaStatusEffects.OnCardPlayedReduceAttackEffect1ToSelf] = "On Card Played Reduce Attack Effect 1 To Self",
			[VanillaStatusEffects.OnCardPlayedReduceCounterToAllies] = "On Card Played Reduce Counter To Allies",
			[VanillaStatusEffects.OnCardPlayedSacrificeRandomAlly] = "On Card Played Sacrifice RandomAlly",
			[VanillaStatusEffects.OnCardPlayedTakeHealthFromAllies] = "On Card Played Take Health From Allies",
			[VanillaStatusEffects.OnCardPlayedTriggerAgainstAllyBehind] = "On Card Played Trigger Against AllyBehind",
			[VanillaStatusEffects.OnCardPlayedTriggerRandomAlly] = "On Card Played Trigger RandomAlly",
			[VanillaStatusEffects.OnCardPlayedUseRandomItemInHandAgainstRandomEnemy] = "On Card Played Use Random Item In Hand Against Random Enemy",
			[VanillaStatusEffects.OnCardPlayedVimToAllies] = "On Card Played Vim To Allies",
			[VanillaStatusEffects.OnCardPlayedVimToSelf] = "On Card Played Vim To Self",
			[VanillaStatusEffects.OnCardPlayedVoidToEnemies] = "On Card Played Void To Enemies",
			[VanillaStatusEffects.OnHitDamageDamagedTarget] = "On Hit Damage Damaged Target",
			[VanillaStatusEffects.OnHitDamageFrostedTarget] = "On Hit Damage Frosted Target",
			[VanillaStatusEffects.OnHitDamageShelledTarget] = "On Hit Damage Shelled Target",
			[VanillaStatusEffects.OnHitDamageSnowedTarget] = "On Hit Damage Snowed Target",
			[VanillaStatusEffects.OnHitEqualDamageToInkedTarget] = "On Hit Equal Damage To Inked Target",
			[VanillaStatusEffects.OnHitEqualHealToFrontAlly] = "On Hit Equal Heal To FrontAlly",
			[VanillaStatusEffects.OnHitEqualOverloadToTarget] = "On Hit Equal Overload To Target",
			[VanillaStatusEffects.OnHitEqualSnowToTarget] = "On Hit Equal Snow To Target",
			[VanillaStatusEffects.OnHitPullTarget] = "On Hit Pull Target",
			[VanillaStatusEffects.OnHitPushTarget] = "On Hit Push Target",
			[VanillaStatusEffects.OnKillApplyAttackToSelf] = "On Kill Apply Attack To Self",
			[VanillaStatusEffects.OnKillApplyBlockToSelf] = "On Kill Apply Block To Self",
			[VanillaStatusEffects.OnKillApplyGoldToSelf] = "On Kill Apply Gold To Self",
			[VanillaStatusEffects.OnKillApplyScrapToAllies] = "On Kill Apply Scrap To Allies",
			[VanillaStatusEffects.OnKillApplyScrapToAllyBehind] = "On Kill Apply Scrap To AllyBehind",
			[VanillaStatusEffects.OnKillApplyScrapToRandomAlly] = "On Kill Apply Scrap To RandomAlly",
			[VanillaStatusEffects.OnKillApplyShellToSelf] = "On Kill Apply Shell To Self",
			[VanillaStatusEffects.OnKillApplyStealthToSelf] = "On Kill Apply Stealth To Self",
			[VanillaStatusEffects.OnKillApplyTeethToSelf] = "On Kill Apply Teeth To Self",
			[VanillaStatusEffects.OnKillApplyVimToAllyBehind] = "On Kill Apply Vim To AllyBehind",
			[VanillaStatusEffects.OnKillApplyVimToRandomAlly] = "On Kill Apply Vim To RandomAlly",
			[VanillaStatusEffects.OnKillApplyVimToRandomEnemy] = "On Kill Apply Vim To RandomEnemy",
			[VanillaStatusEffects.OnKillDraw] = "On Kill Draw",
			[VanillaStatusEffects.OnKillHealToSelfAndAlliesInRow] = "On Kill Heal To Self & AlliesInRow",
			[VanillaStatusEffects.OnKillHealToSelf] = "On Kill Heal To Self",
			[VanillaStatusEffects.OnKillIncreaseHealthToSelfAndAllies] = "On Kill Increase Health To Self & Allies",
			[VanillaStatusEffects.OnTurnApplyAttackToSelf] = "On Turn Apply Attack To Self",
			[VanillaStatusEffects.OnTurnApplyDemonizeToRandomEnemy] = "On Turn Apply Demonize To RandomEnemy",
			[VanillaStatusEffects.OnTurnApplyInkToEnemies] = "On Turn Apply Ink To Enemies",
			[VanillaStatusEffects.OnTurnApplyInkToRandomEnemy] = "On Turn Apply Ink To RandomEnemy",
			[VanillaStatusEffects.OnTurnApplyJuiceToAllyBehind] = "On Turn Apply Juice To AllyBehind",
			[VanillaStatusEffects.OnTurnApplyOverloadToRandomEnemy] = "On Turn Apply Overload To RandomEnemy",
			[VanillaStatusEffects.OnTurnApplyScrapToAllyAhead] = "On Turn Apply Scrap To AllyAhead",
			[VanillaStatusEffects.OnTurnApplyScrapToAllyBehind] = "On Turn Apply Scrap To AllyBehind",
			[VanillaStatusEffects.OnTurnApplyScrapToRandomAlly] = "On Turn Apply Scrap To RandomAlly",
			[VanillaStatusEffects.OnTurnApplyScrapToSelf] = "On Turn Apply Scrap To Self",
			[VanillaStatusEffects.OnTurnApplyShellToAllies] = "On Turn Apply Shell To Allies",
			[VanillaStatusEffects.OnTurnApplyShellToAllyInFrontOf] = "On Turn Apply Shell To AllyInFrontOf",
			[VanillaStatusEffects.OnTurnApplyShellToSelf] = "On Turn Apply Shell To Self",
			[VanillaStatusEffects.OnTurnApplySnowToEnemies] = "On Turn Apply Snow To Enemies",
			[VanillaStatusEffects.OnTurnApplySpiceToAllies] = "On Turn Apply Spice To Allies",
			[VanillaStatusEffects.OnTurnApplySpiceToAllyBehind] = "On Turn Apply Spice To AllyBehind",
			[VanillaStatusEffects.OnTurnApplySpiceToAllyInFrontOf] = "On Turn Apply Spice To AllyInFrontOf",
			[VanillaStatusEffects.OnTurnApplyTeethToSelf] = "On Turn Apply Teeth To Self",
			[VanillaStatusEffects.OnTurnApplyVimToAllyBehind] = "On Turn Apply Vim To AllyBehind",
			[VanillaStatusEffects.OnTurnApplyVimToRandomAlly] = "On Turn Apply Vim To RandomAlly",
			[VanillaStatusEffects.OnTurnApplyVoidToEveryone] = "On Turn Apply Void To Everyone",
			[VanillaStatusEffects.OnTurnApplyVoidToRandomEnemy] = "On Turn Apply Void To RandomEnemy",
			[VanillaStatusEffects.OnTurnEatRandomAllyHealthAndAttackAndEffects] = "On Turn Eat Random Ally (Health, Attack & Effects)",
			[VanillaStatusEffects.OnTurnEscapeToSelf] = "On Turn Escape To Self",
			[VanillaStatusEffects.OnTurnHealAllies] = "On Turn Heal Allies",
			[VanillaStatusEffects.OngoingIncreaseAttack] = "Ongoing Increase Attack",
			[VanillaStatusEffects.OngoingIncreaseEffectFactor] = "Ongoing Increase Effect Factor",
			[VanillaStatusEffects.OngoingIncreaseEffects] = "Ongoing Increase Effects",
			[VanillaStatusEffects.OngoingReduceAttack] = "Ongoing Reduce Attack",
			[VanillaStatusEffects.Overload] = "Overload",
			[VanillaStatusEffects.PreTriggerGainTempMultiHitEqualToJuice1] = "Pre Trigger Gain Temp MultiHit Equal To Juice - 1",
			[VanillaStatusEffects.PreTriggerGainTempMultiHitEqualToScrap1] = "Pre Trigger Gain Temp MultiHit Equal To Scrap - 1",
			[VanillaStatusEffects.PreTurnDestroyAllItemsInHand] = "Pre Turn Destroy All Items In Hand",
			[VanillaStatusEffects.PreTurnDestroyRandomCardInHand] = "Pre Turn Destroy Random Card In Hand",
			[VanillaStatusEffects.PreTurnEatAlliesInRowHealthAndAttack] = "Pre Turn Eat Allies In Row (Health & Attack)",
			[VanillaStatusEffects.PreTurnEatRandomAllyHealthAndAttackAndEffects] = "Pre Turn Eat Random Ally (Health, Attack & Effects)",
			[VanillaStatusEffects.PreTurnGainAttackForEachItemInHandForEachCardDestroyed] = "Pre Turn Gain Attack For Each Item In Hand (For Each Card Destroyed)",
			[VanillaStatusEffects.PreTurnGainTempMultiHitEqualToJuice] = "Pre Turn Gain Temp MultiHit Equal To Juice",
			[VanillaStatusEffects.PreTurnTakeJuiceFromRandomAlly] = "Pre Turn Take Juice From RandomAlly",
			[VanillaStatusEffects.PreTurnTakeScrapFromRandomAlly] = "Pre Turn Take Scrap From RandomAlly",
			[VanillaStatusEffects.Pull] = "Pull",
			[VanillaStatusEffects.Push] = "Push",
			[VanillaStatusEffects.RecycleJunk] = "Recycle Junk",
			[VanillaStatusEffects.RedrawCards] = "Redraw Cards",
			[VanillaStatusEffects.ReduceAttackEffect1] = "Reduce Attack Effect 1",
			[VanillaStatusEffects.ReduceAttack] = "Reduce Attack",
			[VanillaStatusEffects.ReduceCounter] = "Reduce Counter",
			[VanillaStatusEffects.ReduceEffects] = "Reduce Effects",
			[VanillaStatusEffects.ReduceMaxCounter] = "Reduce Max Counter",
			[VanillaStatusEffects.ReduceMaxHealthMustbeally] = "Reduce Max Health (Must be ally)",
			[VanillaStatusEffects.ReduceMaxHealth] = "Reduce Max Health",
			[VanillaStatusEffects.ResistShroom] = "ResistShroom",
			[VanillaStatusEffects.ResistSnow] = "ResistSnow",
			[VanillaStatusEffects.ResistSpice] = "ResistSpice",
			[VanillaStatusEffects.SacrificeAlly] = "Sacrifice Ally",
			[VanillaStatusEffects.SacrificeCardInHand] = "Sacrifice Card In Hand",
			[VanillaStatusEffects.SacrificeEnemy] = "Sacrifice Enemy",
			[VanillaStatusEffects.Scrap] = "Scrap",
			[VanillaStatusEffects.SetHealth] = "Set Health",
			[VanillaStatusEffects.SetMaxHealth] = "Set Max Health",
			[VanillaStatusEffects.Shell] = "Shell",
			[VanillaStatusEffects.Shroom] = "Shroom",
			[VanillaStatusEffects.Snow] = "Snow",
			[VanillaStatusEffects.SoulboundBossPhase2] = "SoulboundBossPhase2",
			[VanillaStatusEffects.Spice] = "Spice",
			[VanillaStatusEffects.Split] = "Split",
			[VanillaStatusEffects.SplitBossPhase2] = "SplitBossPhase2",
			[VanillaStatusEffects.Stealth] = "Stealth",
			[VanillaStatusEffects.SummonBeepop] = "Summon Beepop",
			[VanillaStatusEffects.SummonBloo] = "Summon Bloo",
			[VanillaStatusEffects.SummonBoBo] = "Summon BoBo",
			[VanillaStatusEffects.SummonBonzo] = "Summon Bonzo",
			[VanillaStatusEffects.SummonDregg] = "Summon Dregg",
			[VanillaStatusEffects.SummonEnemyLeech] = "Summon Enemy Leech",
			[VanillaStatusEffects.SummonEnemyPigeon] = "Summon Enemy Pigeon",
			[VanillaStatusEffects.SummonEnemyPopper] = "Summon Enemy Popper",
			[VanillaStatusEffects.SummonFallow] = "Summon Fallow",
			[VanillaStatusEffects.SummonGearhammer] = "Summon Gearhammer",
			[VanillaStatusEffects.SummonItem] = "Summon Item",
			[VanillaStatusEffects.SummonJunk] = "Summon Junk",
			[VanillaStatusEffects.SummonPlep] = "Summon Plep",
			[VanillaStatusEffects.SummonSunShard] = "Summon SunShard",
			[VanillaStatusEffects.SummonTailsFive] = "Summon TailsFive",
			[VanillaStatusEffects.SummonTailsFour] = "Summon TailsFour",
			[VanillaStatusEffects.SummonTailsOne] = "Summon TailsOne",
			[VanillaStatusEffects.SummonTailsThree] = "Summon TailsThree",
			[VanillaStatusEffects.SummonTailsTwo] = "Summon TailsTwo",
			[VanillaStatusEffects.SummonTigris] = "Summon Tigris",
			[VanillaStatusEffects.SummonUzu] = "Summon Uzu",
			[VanillaStatusEffects.Summoned] = "Summoned",
			[VanillaStatusEffects.Take100DamageWhenSoulboundUnitKilled] = "Take 100 Damage When Soulbound Unit Killed",
			[VanillaStatusEffects.TakeHealth] = "Take Health",
			[VanillaStatusEffects.Teeth] = "Teeth",
			[VanillaStatusEffects.TemporaryAimless] = "Temporary Aimless",
			[VanillaStatusEffects.TemporaryBarrage] = "Temporary Barrage",
			[VanillaStatusEffects.TemporaryFury] = "Temporary Fury",
			[VanillaStatusEffects.TemporaryNoomlin] = "Temporary Noomlin",
			[VanillaStatusEffects.TemporaryPigheaded] = "Temporary Pigheaded",
			[VanillaStatusEffects.TemporarySoulbound] = "Temporary Soulbound",
			[VanillaStatusEffects.TemporarySummoned] = "Temporary Summoned",
			[VanillaStatusEffects.TemporaryUnbreakable] = "Temporary Unbreakable",
			[VanillaStatusEffects.TemporaryUnmovable] = "Temporary Unmovable",
			[VanillaStatusEffects.TriggerAgainstAndReduceUses] = "Trigger Against & Reduce Uses",
			[VanillaStatusEffects.TriggerAgainstDontCountAsTrigger] = "Trigger Against (Don't Count As Trigger)",
			[VanillaStatusEffects.TriggerAgainstAllyWhenAllyIsHit] = "Trigger Against Ally When Ally Is Hit",
			[VanillaStatusEffects.TriggerAgainstAttackerWhenHit] = "Trigger Against Attacker When Hit",
			[VanillaStatusEffects.TriggerAgainstCrownAlliesWhenDiscarded] = "Trigger Against Crown Allies When Discarded",
			[VanillaStatusEffects.TriggerAgainstCrownAlliesWhenDrawn] = "Trigger Against Crown Allies When Drawn",
			[VanillaStatusEffects.TriggerAgainstRandomAllyWhenDiscarded] = "Trigger Against Random Ally When Discarded",
			[VanillaStatusEffects.TriggerAgainstRandomAllyWhenDrawn] = "Trigger Against Random Ally When Drawn",
			[VanillaStatusEffects.TriggerAgainstRandomEnemy] = "Trigger Against Random Enemy",
			[VanillaStatusEffects.TriggerAgainstRandomUnitWhenDiscarded] = "Trigger Against Random Unit When Discarded",
			[VanillaStatusEffects.TriggerAgainstRandomUnitWhenDrawn] = "Trigger Against Random Unit When Drawn",
			[VanillaStatusEffects.TriggerAgainstWhenAllyAttacks] = "Trigger Against When Ally Attacks",
			[VanillaStatusEffects.TriggerAgainstWhenFrostApplied] = "Trigger Against When Frost Applied",
			[VanillaStatusEffects.TriggerAgainstWhenSnowApplied] = "Trigger Against When Snow Applied",
			[VanillaStatusEffects.TriggerAgainstWhenWeaknessApplied] = "Trigger Against When Weakness Applied",
			[VanillaStatusEffects.TriggerAgainst] = "Trigger Against",
			[VanillaStatusEffects.TriggerWhenAllyAttacks] = "Trigger When Ally Attacks",
			[VanillaStatusEffects.TriggerWhenAllyInRowAttacks] = "Trigger When Ally In Row Attacks",
			[VanillaStatusEffects.TriggerWhenAllyIsHit] = "Trigger When Ally Is Hit",
			[VanillaStatusEffects.TriggerWhenDeployed] = "Trigger When Deployed",
			[VanillaStatusEffects.TriggerWhenEnemyIsKilled] = "Trigger When Enemy Is Killed",
			[VanillaStatusEffects.TriggerWhenJunkDestroyed] = "Trigger When Junk Destroyed",
			[VanillaStatusEffects.TriggerWhenRedrawHit] = "Trigger When Redraw Hit",
			[VanillaStatusEffects.Trigger] = "Trigger",
			[VanillaStatusEffects.Unmovable] = "Unmovable",
			[VanillaStatusEffects.Weakness] = "Weakness",
			[VanillaStatusEffects.WhenAllyIsHealedApplyEqualSpice] = "When Ally Is Healed Apply Equal Spice",
			[VanillaStatusEffects.WhenAllyIsHealedTriggerToSelf] = "When Ally Is Healed Trigger To Self",
			[VanillaStatusEffects.WhenAllyisHitApplyFrostToAttacker] = "When Ally is Hit Apply Frost To Attacker",
			[VanillaStatusEffects.WhenAllyisHitApplyShroomToAttacker] = "When Ally is Hit Apply Shroom To Attacker",
			[VanillaStatusEffects.WhenAllyisHitApplyTeethToSelf] = "When Ally is Hit Apply Teeth To Self",
			[VanillaStatusEffects.WhenAllyisHitApplyVimToTarget] = "When Ally is Hit Apply Vim To Target",
			[VanillaStatusEffects.WhenAllyisHitHealToTarget] = "When Ally is Hit Heal To Target",
			[VanillaStatusEffects.WhenAllyisHitIncreaseHealthToSelf] = "When Ally is Hit Increase Health To Self",
			[VanillaStatusEffects.WhenAllyIsKilledApplyAttackToSelf] = "When Ally Is Killed Apply Attack To Self",
			[VanillaStatusEffects.WhenAllyIsKilledGainTheirAttack] = "When Ally Is Killed Gain Their Attack",
			[VanillaStatusEffects.WhenAllyIsKilledLoseHalfHealthAndGainAttack] = "When Ally Is Killed Lose Half Health & Gain Attack",
			[VanillaStatusEffects.WhenAllyIsKilledTriggerToSelf] = "When Ally Is Killed Trigger To Self",
			[VanillaStatusEffects.WhenAllyIsSacrificedGainTheirAttack] = "When Ally Is Sacrificed Gain Their Attack",
			[VanillaStatusEffects.WhenAllyIsSacrificedTriggerToSelf] = "When Ally Is Sacrificed Trigger To Self",
			[VanillaStatusEffects.WhenAnyoneTakesShroomDamageApplyAttackToSelf] = "When Anyone Takes Shroom Damage Apply Attack To Self",
			[VanillaStatusEffects.WhenBuiltAddJunkToHand] = "When Built Add Junk To Hand",
			[VanillaStatusEffects.WhenBuiltApplyVimToSelf] = "When Built Apply Vim To Self",
			[VanillaStatusEffects.WhenCardDestroyedAndGainAttack] = "When Card Destroyed, Gain Attack",
			[VanillaStatusEffects.WhenCardDestroyedAndGainJuice] = "When Card Destroyed, Gain Juice",
			[VanillaStatusEffects.WhenCardDestroyedAndReduceCounterToSelf] = "When Card Destroyed, Reduce Counter To Self",
			[VanillaStatusEffects.WhenConsumedAddHealthToAllies] = "When Consumed Add Health To Allies",
			[VanillaStatusEffects.WhenConsumedApplyOverloadToEnemies] = "When Consumed Apply Overload To Enemies",
			[VanillaStatusEffects.WhenDeployedAddJunkToHand] = "When Deployed Add Junk To Hand",
			[VanillaStatusEffects.WhenDeployedApplyBlockToSelf] = "When Deployed Apply Block To Self",
			[VanillaStatusEffects.WhenDeployedApplyFrenzyToSelf] = "When Deployed Apply Frenzy To Self",
			[VanillaStatusEffects.WhenDeployedApplyInkToAllies] = "When Deployed Apply Ink To Allies",
			[VanillaStatusEffects.WhenDeployedApplyInkToEnemiesInRow] = "When Deployed Apply Ink To EnemiesInRow",
			[VanillaStatusEffects.WhenDeployedCopyEffectsOfRandomEnemy] = "When Deployed Copy Effects Of RandomEnemy",
			[VanillaStatusEffects.WhenDeployedFillBoardFinalBoss] = "When Deployed Fill Board (Final Boss)",
			[VanillaStatusEffects.WhenDeployedSummonWowee] = "When Deployed Summon Wowee",
			[VanillaStatusEffects.WhenDestroyedApplyDamageToAlliesInRow] = "When Destroyed Apply Damage To AlliesInRow",
			[VanillaStatusEffects.WhenDestroyedApplyDamageToAttacker] = "When Destroyed Apply Damage To Attacker",
			[VanillaStatusEffects.WhenDestroyedApplyDamageToEnemiesEqualToJuice] = "When Destroyed Apply Damage To Enemies Equal To Juice",
			[VanillaStatusEffects.WhenDestroyedApplyDamageToEnemiesInRow] = "When Destroyed Apply Damage To EnemiesInRow",
			[VanillaStatusEffects.WhenDestroyedApplyFrenzyToRandomAlly] = "When Destroyed Apply Frenzy To RandomAlly",
			[VanillaStatusEffects.WhenDestroyedApplyHazeToAttacker] = "When Destroyed Apply Haze To Attacker",
			[VanillaStatusEffects.WhenDestroyedApplyOverloadToAttacker] = "When Destroyed Apply Overload To Attacker",
			[VanillaStatusEffects.WhenDestroyedApplySpiceToAllies] = "When Destroyed Apply Spice To Allies",
			[VanillaStatusEffects.WhenDestroyedApplyStealthToAlliesInRow] = "When Destroyed Apply Stealth To AlliesInRow",
			[VanillaStatusEffects.WhenDestroyedSummonDregg] = "When Destroyed Summon Dregg",
			[VanillaStatusEffects.WhenDestroyedTriggerToAllies] = "When Destroyed Trigger To Allies",
			[VanillaStatusEffects.WhenDrawnApplySnowToAllies] = "When Drawn Apply Snow To Allies",
			[VanillaStatusEffects.WhenEnemiesAttackApplyDemonizeToAttacker] = "When Enemies Attack Apply Demonize To Attacker",
			[VanillaStatusEffects.WhenEnemyShroomedIsKilledApplyTheirShroomToRandomEnemy] = "When Enemy (Shroomed) Is Killed Apply Their Shroom To RandomEnemy",
			[VanillaStatusEffects.WhenEnemyDeployedCopyEffectsOfTarget] = "When Enemy Deployed Copy Effects Of Target",
			[VanillaStatusEffects.WhenEnemyIsKilledApplyGoldToSelf] = "When Enemy Is Killed Apply Gold To Self",
			[VanillaStatusEffects.WhenEnemyIsKilledApplyShellToAttacker] = "When Enemy Is Killed Apply Shell To Attacker",
			[VanillaStatusEffects.WhenHealedApplyAttackToSelf] = "When Healed Apply Attack To Self",
			[VanillaStatusEffects.WhenHealedTriggerToSelf] = "When Healed Trigger To Self",
			[VanillaStatusEffects.WhenHealthLostApplyEqualAttackToSelfAndAllies] = "When Health Lost Apply Equal Attack To Self And Allies",
			[VanillaStatusEffects.WhenHealthLostApplyEqualFrostToSelf] = "When Health Lost Apply Equal Frost To Self",
			[VanillaStatusEffects.WhenHealthLostApplyEqualSpiceToSelf] = "When Health Lost Apply Equal Spice To Self",
			[VanillaStatusEffects.WhenHitAddFrenzyToSelf] = "When Hit Add Frenzy To Self",
			[VanillaStatusEffects.WhenHitAddGearhammerToHand] = "When Hit Add Gearhammer To Hand",
			[VanillaStatusEffects.WhenHitAddHealthLostToAttacker] = "When Hit Add Health Lost To Attacker",
			[VanillaStatusEffects.WhenHitAddHealthLostToRandomAlly] = "When Hit Add Health Lost To RandomAlly",
			[VanillaStatusEffects.WhenHitAddJunkToHand] = "When Hit Add Junk To Hand",
			[VanillaStatusEffects.WhenHitApplyBlockToRandomAlly] = "When Hit Apply Block To RandomAlly",
			[VanillaStatusEffects.WhenHitApplyDemonizeToAttacker] = "When Hit Apply Demonize To Attacker",
			[VanillaStatusEffects.WhenHitApplyFrostToEnemies] = "When Hit Apply Frost To Enemies",
			[VanillaStatusEffects.WhenHitApplyFrostToRandomEnemy] = "When Hit Apply Frost To RandomEnemy",
			[VanillaStatusEffects.WhenHitApplyGoldToAttackerNoPing] = "When Hit Apply Gold To Attacker (No Ping)",
			[VanillaStatusEffects.WhenHitApplyInkToAttacker] = "When Hit Apply Ink To Attacker",
			[VanillaStatusEffects.WhenHitApplyInkToRandomEnemy] = "When Hit Apply Ink To RandomEnemy",
			[VanillaStatusEffects.WhenHitApplyInkToSelf] = "When Hit Apply Ink To Self",
			[VanillaStatusEffects.WhenHitApplyOverloadToAttacker] = "When Hit Apply Overload To Attacker",
			[VanillaStatusEffects.WhenHitApplyShellToAllies] = "When Hit Apply Shell To Allies",
			[VanillaStatusEffects.WhenHitApplyShellToAllyBehind] = "When Hit Apply Shell To AllyBehind",
			[VanillaStatusEffects.WhenHitApplyShellToSelf] = "When Hit Apply Shell To Self",
			[VanillaStatusEffects.WhenHitApplyShroomToAttacker] = "When Hit Apply Shroom To Attacker",
			[VanillaStatusEffects.WhenHitApplyShroomToRandomEnemy] = "When Hit Apply Shroom To RandomEnemy",
			[VanillaStatusEffects.WhenHitApplySnowToAttacker] = "When Hit Apply Snow To Attacker",
			[VanillaStatusEffects.WhenHitApplySnowToEnemies] = "When Hit Apply Snow To Enemies",
			[VanillaStatusEffects.WhenHitApplySnowToRandomEnemy] = "When Hit Apply Snow To RandomEnemy",
			[VanillaStatusEffects.WhenHitApplySpiceToAlliesAndEnemiesAndSelf] = "When Hit Apply Spice To Allies & Enemies & Self",
			[VanillaStatusEffects.WhenHitApplySpiceToAllies] = "When Hit Apply Spice To Allies",
			[VanillaStatusEffects.WhenHitApplySpiceToAlliesInRow] = "When Hit Apply Spice To AlliesInRow",
			[VanillaStatusEffects.WhenHitApplySpiceToSelf] = "When Hit Apply Spice To Self",
			[VanillaStatusEffects.WhenHitApplyStealthToSelf] = "When Hit Apply Stealth To Self",
			[VanillaStatusEffects.WhenHitApplyVimToSelf] = "When Hit Apply Vim To Self",
			[VanillaStatusEffects.WhenHitApplyVoidToAttacker] = "When Hit Apply Void To Attacker",
			[VanillaStatusEffects.WhenHitApplyWeaknessToAttacker] = "When Hit Apply Weakness To Attacker",
			[VanillaStatusEffects.WhenHitDamageToEnemies] = "When Hit Damage To Enemies",
			[VanillaStatusEffects.WhenHitDamageToEnemiesInRow] = "When Hit Damage To EnemiesInRow",
			[VanillaStatusEffects.WhenHitDraw] = "When Hit Draw",
			[VanillaStatusEffects.WhenHitEqualDamageToAttacker] = "When Hit Equal Damage To Attacker",
			[VanillaStatusEffects.WhenHitGainAttackToSelfNoPing] = "When Hit Gain Attack To Self (No Ping)",
			[VanillaStatusEffects.WhenHitGainTeethToSelf] = "When Hit Gain Teeth To Self",
			[VanillaStatusEffects.WhenHitIncreaseAttackEffect1ToSelf] = "When Hit Increase Attack Effect 1 To Self",
			[VanillaStatusEffects.WhenHitIncreaseAttackToRandomAlly] = "When Hit Increase Attack To RandomAlly",
			[VanillaStatusEffects.WhenHitIncreaseHealthToRandomAlly] = "When Hit Increase Health To RandomAlly",
			[VanillaStatusEffects.WhenHitReduceAttackToAttacker] = "When Hit Reduce Attack To Attacker",
			[VanillaStatusEffects.WhenHitReduceAttackToSelf] = "When Hit Reduce Attack To Self",
			[VanillaStatusEffects.WhenHitReduceCounterToSelf] = "When Hit Reduce Counter To Self",
			[VanillaStatusEffects.WhenHitTriggerToSelf] = "When Hit Trigger To Self",
			[VanillaStatusEffects.WhenHitWithJunkAddFrenzyToSelf] = "When Hit With Junk Add Frenzy To Self",
			[VanillaStatusEffects.WhenJuiceAppliedToSelfGainFrenzy] = "When Juice Applied To Self Gain Frenzy",
			[VanillaStatusEffects.WhenSacrificedSummonTailsFour] = "When Sacrificed Summon TailsFour",
			[VanillaStatusEffects.WhenSacrificedSummonTailsOne] = "When Sacrificed Summon TailsOne",
			[VanillaStatusEffects.WhenSacrificedSummonTailsThree] = "When Sacrificed Summon TailsThree",
			[VanillaStatusEffects.WhenSacrificedSummonTailsTwo] = "When Sacrificed Summon TailsTwo",
			[VanillaStatusEffects.WhenShellAppliedToSelfGainSpiceInstead] = "When Shell Applied To Self Gain Spice Instead",
			[VanillaStatusEffects.WhenShroomAppliedToAnythingDoubleAmountAndLoseScrap] = "When Shroom Applied To Anything Double Amount And Lose Scrap",
			[VanillaStatusEffects.WhenShroomDamageTakenTriggerToSelf] = "When Shroom Damage Taken Trigger To Self",
			[VanillaStatusEffects.WhenSnowAppliedToAnythingGainAttackToSelf] = "When Snow Applied To Anything Gain Attack To Self",
			[VanillaStatusEffects.WhenSnowAppliedToAnythingGainEqualAttackToSelf] = "When Snow Applied To Anything Gain Equal Attack To Self",
			[VanillaStatusEffects.WhenSnowAppliedToSelfApplyDemonizeToEnemies] = "When Snow Applied To Self Apply Demonize To Enemies",
			[VanillaStatusEffects.WhenSnowAppliedToSelfGainEqualAttack] = "When Snow Applied To Self Gain Equal Attack",
			[VanillaStatusEffects.WhenSpiceXAppliedToSelfTriggerToSelf] = "When Spice X Applied To Self Trigger To Self",
			[VanillaStatusEffects.WhenVimAppliedToAnythingDoubleAmount] = "When Vim Applied To Anything Double Amount",
			[VanillaStatusEffects.WhenXHealthLostSplit] = "When X Health Lost Split",
			[VanillaStatusEffects.WhileActiveAddEqualAttackToJunkInHand] = "While Active Add Equal Attack To Junk In Hand",
			[VanillaStatusEffects.WhileActiveAimlessToEnemies] = "While Active Aimless To Enemies",
			[VanillaStatusEffects.WhileActiveBarrageToAllies] = "While Active Barrage To Allies",
			[VanillaStatusEffects.WhileActiveBarrageToAlliesInRow] = "While Active Barrage To AlliesInRow",
			[VanillaStatusEffects.WhileActiveBarrageToEnemies] = "While Active Barrage To Enemies",
			[VanillaStatusEffects.WhileActiveFrenzyToAllies] = "While Active Frenzy To Allies",
			[VanillaStatusEffects.WhileActiveFrenzyToCrownAllies] = "While Active Frenzy To Crown Allies",
			[VanillaStatusEffects.WhileActiveHaltSpiceToAllies] = "While Active Halt Spice To Allies",
			[VanillaStatusEffects.WhileActiveIncreaseAllSpiceApplied] = "While Active Increase All Spice Applied",
			[VanillaStatusEffects.WhileActiveIncreaseAttackbyCurrentToAllies] = "While Active Increase Attack by Current To Allies",
			[VanillaStatusEffects.WhileActiveIncreaseAttackbyCurrentToSummonedAllies] = "While Active Increase Attack by Current To Summoned Allies",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToAlliesAndEnemies] = "While Active Increase Attack To Allies & Enemies",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToAlliesNoDesc] = "While Active Increase Attack To Allies (No Desc)",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToAllies] = "While Active Increase Attack To Allies",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToAlliesInRow] = "While Active Increase Attack To AlliesInRow",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToItemsInHand] = "While Active Increase Attack To Items In Hand",
			[VanillaStatusEffects.WhileActiveIncreaseAttackToJunkInHand] = "While Active Increase Attack To Junk In Hand",
			[VanillaStatusEffects.WhileActiveIncreaseEffectsToAlliesAndEnemies] = "While Active Increase Effects To Allies & Enemies",
			[VanillaStatusEffects.WhileActiveIncreaseEffectsToFrontAlly] = "While Active Increase Effects To FrontAlly",
			[VanillaStatusEffects.WhileActiveIncreaseEffectsToHand] = "While Active Increase Effects To Hand",
			[VanillaStatusEffects.WhileActivePigheadedToEnemies] = "While Active Pigheaded To Enemies",
			[VanillaStatusEffects.WhileActiveReduceAttackToEnemiesNoPingAndNoDesc] = "While Active Reduce Attack To Enemies (No Ping, No Desc)",
			[VanillaStatusEffects.WhileActiveSnowImmuneToAllies] = "While Active Snow Immune To Allies",
			[VanillaStatusEffects.WhileActiveTeethToAllies] = "While Active Teeth To Allies",
			[VanillaStatusEffects.WhileActiveUnmovableToEnemies] = "While Active Unmovable To Enemies",
			[VanillaStatusEffects.WhileInHandReduceAttackToAllies] = "While In Hand Reduce Attack To Allies",
			[VanillaStatusEffects.WhileLastInHandDoubleEffectsToSelf] = "While Last In Hand Double Effects To Self"
		};

		public static readonly Dictionary<VanillaTraits, string> VanillaTraitsNamesLookUp = new Dictionary<VanillaTraits, string>
		{
			[VanillaTraits.Aimless] = "Aimless",
			[VanillaTraits.Backline] = "Backline",
			[VanillaTraits.Barrage] = "Barrage",
			[VanillaTraits.Bombard1] = "Bombard 1",
			[VanillaTraits.Bombard2] = "Bombard 2",
			[VanillaTraits.Combo] = "Combo",
			[VanillaTraits.Consume] = "Consume",
			[VanillaTraits.Crush] = "Crush",
			[VanillaTraits.Draw] = "Draw",
			[VanillaTraits.Effigy] = "Effigy",
			[VanillaTraits.Explode] = "Explode",
			[VanillaTraits.Frontline] = "Frontline",
			[VanillaTraits.Fury] = "Fury",
			[VanillaTraits.Greed] = "Greed",
			[VanillaTraits.Hellbent] = "Hellbent",
			[VanillaTraits.Knockback] = "Knockback",
			[VanillaTraits.Longshot] = "Longshot",
			[VanillaTraits.Noomlin] = "Noomlin",
			[VanillaTraits.Pigheaded] = "Pigheaded",
			[VanillaTraits.Pull] = "Pull",
			[VanillaTraits.Recycle] = "Recycle",
			[VanillaTraits.Smackback] = "Smackback",
			[VanillaTraits.Soulbound] = "Soulbound",
			[VanillaTraits.Spark] = "Spark",
			[VanillaTraits.Summoned] = "Summoned",
			[VanillaTraits.Trash] = "Trash",
			[VanillaTraits.Unmovable] = "Unmovable",
			[VanillaTraits.Wild] = "Wild"
		};

		public static readonly Dictionary<VanillaBloodProfiles, string> VanillaBloodProfilesNamesLookUp = new Dictionary<VanillaBloodProfiles, string>
		{
			[VanillaBloodProfiles.BloodProfileBerry] = "Blood Profile Berry",
			[VanillaBloodProfiles.BloodProfileBlack] = "Blood Profile Black",
			[VanillaBloodProfiles.BloodProfileBlueDouble] = "Blood Profile Blue (x2)",
			[VanillaBloodProfiles.BloodProfileFungus] = "Blood Profile Fungus",
			[VanillaBloodProfiles.BloodProfileNormal] = "Blood Profile Normal",
			[VanillaBloodProfiles.BloodProfileSnow] = "Blood Profile Snow",
			[VanillaBloodProfiles.BloodProfilePinkWisp] = "Blood Profile Pink Wisp",
			[VanillaBloodProfiles.BloodProfileHusk] = "Blood Profile Husk"
		};

		public static event Action<int> OnAskForAddingCards;

		internal static void LaunchEvent()
		{
			if (WildFrostAPIMod.GroupAdditions["CardData"].Count <= 0)
			{
				CardAdder.OnAskForAddingCards?.Invoke(0);
			}
		}

		public static Sprite ToSprite(this Texture2D t, Vector2? v = null)
		{
			//IL_001f: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = (Vector2)(((??)v) ?? new Vector2(0.5f, 0.5f));
			return Sprite.Create(t, new Rect(0f, 0f, (float)((Texture)t).width, (float)((Texture)t).height), val);
		}

		public static Sprite LoadSpriteFromCardPortraits(string name, Vector2? v = null)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(File.ReadAllBytes(WildFrostAPIMod.ModsFolder + (name.EndsWith(".png") ? name : (name + ".png")))));
			return val.ToSprite(v);
		}

		public static CardData RegisterCardInApi(this CardData t)
		{
			t.SetCustomData("AddedByApi", Object.op_Implicit(true));
			t.original = t;
			WildFrostAPIMod.GroupAdditions["CardData"].Add((Object)(object)t);
			return t;
		}

		public static CardData ModifyFields(this CardData t, Func<CardData, CardData> modifyFields)
		{
			t = modifyFields(t);
			return t;
		}

		public static CardData SetSprites(this CardData t, Sprite mainSprite, Sprite backgroundSprite)
		{
			t.mainSprite = mainSprite;
			t.backgroundSprite = backgroundSprite;
			return t;
		}

		public static StatusEffectData StatusEffectData(this VanillaStatusEffects effect)
		{
			return VanillaStatusEffectsNamesLookUp[effect].StatusEffectData();
		}

		public static StatusEffectStacks StatusEffectStack(this VanillaStatusEffects effect, int amount)
		{
			return VanillaStatusEffectsNamesLookUp[effect].StatusEffectStack(amount);
		}

		public static StatusEffectData StatusEffectData(this string name)
		{
			if (!StatusEffectAdder.IsRunning)
			{
				StatusEffectAdder.LaunchEvent();
			}
			List<StatusEffectData> val = IArrayExt.ToList<StatusEffectData>((Il2CppArrayBase<StatusEffectData>)(object)((Il2CppObjectBase)Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<StatusEffectData>())).Cast<Il2CppReferenceArray<StatusEffectData>>());
			foreach (StatusEffectData item in WildFrostAPIMod.GroupAdditions["StatusEffectData"].Cast<StatusEffectData>())
			{
				val.Add(item);
			}
			StatusEffectData val2 = val.Find((StatusEffectData a) => ((Object)a).name == name);
			if ((Object)(object)val2 == (Object)null)
			{
				throw new Exception("Effect with " + name + " not found");
			}
			return (val2 != null) ? ((Il2CppObjectBase)val2).Cast<StatusEffectData>() : null;
		}

		public static StatusEffectStacks StatusEffectStack(this string name, int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			return new StatusEffectStacks
			{
				data = name.StatusEffectData(),
				count = amount
			};
		}

		public static TraitStacks TraitStack(this VanillaTraits trait, int amount)
		{
			return VanillaTraitsNamesLookUp[trait].TraitStack(amount);
		}

		public static TraitStacks TraitStack(this string name, int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			return new TraitStacks
			{
				data = name.TraitData(),
				count = amount
			};
		}

		public static TraitData TraitData(this VanillaTraits trait)
		{
			return VanillaTraitsNamesLookUp[trait].TraitData();
		}

		public static TraitData TraitData(this string name)
		{
			List<TraitData> list = IArrayExt.ToList<TraitData>((Il2CppArrayBase<TraitData>)(object)((Il2CppObjectBase)Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<TraitData>())).Cast<Il2CppReferenceArray<TraitData>>());
			return ((Il2CppObjectBase)list.Find((TraitData a) => ((Object)a).name == name)).Cast<TraitData>();
		}

		public static CardData AddToPool(this CardData t, params VanillaRewardPools[] rewardPools)
		{
			List<string> list = new List<string>();
			for (int i = 0; i < rewardPools.Length; i++)
			{
				VanillaRewardPools vanillaRewardPools = rewardPools[i];
				list.Add(vanillaRewardPools.ToString().Replace("VanillaRewardPools.", ""));
			}
			t = t.AddToPool(list.ToArray());
			return t;
		}

		public static CardData AddToPool(this CardData t, params string[] rewardPools)
		{
			Il2CppReferenceArray<Object> val = Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<RewardPool>());
			foreach (string poolName in rewardPools)
			{
				RewardPool val2 = ((Il2CppObjectBase)IArrayExt.ToList<Object>((Il2CppArrayBase<Object>)(object)val).Find((Object a) => a.name == poolName)).Cast<RewardPool>();
				if (val2 != null)
				{
					val2.list?.Add((DataFile)(object)t);
				}
			}
			return t;
		}

		public static CardData SetIdleAnimationProfile(this CardData t, VanillaCardAnimationProfiles profile)
		{
			return t.SetIdleAnimationProfile(profile.ToString().Replace("VanillaCardAnimationProfiles.", ""));
		}

		public static CardData SetIdleAnimationProfile(this CardData t, CardAnimationProfile profile)
		{
			t.idleAnimationProfile = profile;
			return t;
		}

		public static CardData SetIdleAnimationProfile(this CardData t, string animationProfileName)
		{
			t.idleAnimationProfile = WildFrostAPIMod.VanillaAnimationProfiles.Find((CardAnimationProfile a) => (Object)(object)a != (Object)null && ((Object)a).name.Equals(animationProfileName, StringComparison.OrdinalIgnoreCase));
			if ((Object)(object)t.idleAnimationProfile == (Object)null)
			{
				throw new Exception("Animation profile with name " + animationProfileName + " not found!");
			}
			return t;
		}

		public static CardData SetBloodProfile(this CardData t, VanillaBloodProfiles bloodProfile)
		{
			return t.SetBloodProfile(VanillaBloodProfilesNamesLookUp[bloodProfile]);
		}

		public static CardData SetBloodProfile(this CardData t, BloodProfile bloodProfile)
		{
			t.bloodProfile = bloodProfile;
			return t;
		}

		public static CardData SetBloodProfile(this CardData t, string bloodProfileName)
		{
			t.bloodProfile = WildFrostAPIMod.VanillaBloodProfiles.Find((BloodProfile a) => (Object)(object)a != (Object)null && ((Object)a).name.Equals(bloodProfileName, StringComparison.OrdinalIgnoreCase));
			if ((Object)(object)t.bloodProfile == (Object)null)
			{
				throw new Exception("Blood profile with name " + bloodProfileName + " not found!");
			}
			return t;
		}

		public static CardData SetTargetMode(this CardData t, VanillaTargetModes vanillaTargetMode)
		{
			return t.SetTargetMode(vanillaTargetMode.ToString().Replace("VanillaTargetModes.", ""));
		}

		public static CardData SetTargetMode(this CardData t, TargetMode targetMode)
		{
			t.targetMode = targetMode;
			return t;
		}

		public static CardData SetTargetMode(this CardData t, string targetModeName)
		{
			t.targetMode = WildFrostAPIMod.VanillaTargetModes.Find((TargetMode a) => (Object)(object)a != (Object)null && ((Object)a).name == targetModeName);
			return t;
		}

		public static List<string> Dictinct(this List<string> list)
		{
			List<string> val = new List<string>();
			Enumerator<string> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				string name = enumerator.Current;
				if (val.Find((string a) => string.Equals(a, name, StringComparison.OrdinalIgnoreCase)) == null)
				{
					val.Add(name);
				}
			}
			return val;
		}

		public static IEnumerator FixPetsAmountQWQ()
		{
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)(() => (Object)(object)Object.FindObjectOfType<SelectStartingPet>() != (Object)null)));
			SelectStartingPet selectStartingPet = Object.FindObjectOfType<SelectStartingPet>();
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)(() => selectStartingPet.group.Count > selectStartingPet.pets.Count)));
			if ((Object)(object)selectStartingPet != (Object)null)
			{
				selectStartingPet.pets.Clear();
				selectStartingPet.group.ClearAndDestroyAllImmediately();
				yield return selectStartingPet.SetUp();
			}
			((MonoBehaviour)CoroutineManager.instance).StopCoroutine("FixPetsAmountQWQ");
		}

		public static void AddToPetsIE(CardData t)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			ManualLogSource log = ((BasePlugin)WildFrostAPIMod.Instance).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(23, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Card ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)t).name);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" is added to pets!");
			}
			log.LogInfo(val);
			List<CardData> list = IArrayExt.ToList<CardData>((Il2CppArrayBase<CardData>)(object)((Il2CppObjectBase)Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<CardData>())).Cast<Il2CppReferenceArray<CardData>>());
			List<string> val2 = IArrayExt.ToList<string>((Il2CppArrayBase<string>)(object)((Il2CppObjectBase)MetaprogressionSystem.data["pets"]).Cast<Il2CppStringArray>());
			val2.Add(((Object)t).name);
			foreach (string pet in val2.ToArray())
			{
				if (pet != ((Object)t).name && (Object)(object)list.Find((CardData a) => !ExtensionMethods.IsNullOrDestroyed((Object)(object)a) && ((Object)a).name == pet) == (Object)null && WildFrostAPIMod.GroupAdditions["CardData"].Find((Object a) => !ExtensionMethods.IsNullOrDestroyed((Object)(object)a) && a.name == pet) == (Object)null)
				{
					val2.Remove(pet);
				}
			}
			Il2CppArrayBase<string> val3 = val2.Dictinct().ToArray();
			MetaprogressionSystem.data["pets"] = ((Il2CppObjectBase)val3).Cast<Object>();
			List<string> val4 = new List<string>();
			for (int i = 0; i < val3.Length; i++)
			{
				val4.Add("Pet " + i);
			}
			SaveSystem.SaveProgressData<List<string>>("petHutUnlocks", val4);
		}

		public static CardData AddToPets(this CardData t)
		{
			AddToPetsIE(t);
			return t;
		}

		public static CardData SetStartWithEffects(this CardData t, params StatusEffectStacks[] effect)
		{
			t.startWithEffects = Il2CppReferenceArray<StatusEffectStacks>.op_Implicit(effect);
			return t;
		}

		public static CardData SetUpgrades(this CardData t, List<string> upgrade)
		{
			List<CardUpgradeData> val = new List<CardUpgradeData>();
			Enumerator<string> enumerator = upgrade.GetEnumerator();
			while (enumerator.MoveNext())
			{
				string current = enumerator.Current;
				val.Add(((Il2CppObjectBase)AddressableLoader.groups["CardUpgradeData"].lookup[current]).Cast<CardUpgradeData>());
			}
			return t;
		}

		public static CardData SetUpgrades(this CardData t, List<VanillaCardUpgrades> upgrade)
		{
			List<CardUpgradeData> val = new List<CardUpgradeData>();
			Enumerator<VanillaCardUpgrades> enumerator = upgrade.GetEnumerator();
			while (enumerator.MoveNext())
			{
				VanillaCardUpgrades current = enumerator.Current;
				val.Add(((Il2CppObjectBase)AddressableLoader.groups["CardUpgradeData"].lookup[current.ToString().Replace("VanillaCardUpgrades.", "")]).Cast<CardUpgradeData>());
			}
			return t;
		}

		public static CardData SetUpgrades(this CardData t, List<CardUpgradeData> upgrade)
		{
			t.upgrades = upgrade;
			return t;
		}

		public static CardData SetAttackEffects(this CardData t, params StatusEffectStacks[] effect)
		{
			t.attackEffects = Il2CppReferenceArray<StatusEffectStacks>.op_Implicit(effect);
			return t;
		}

		public static CardData SetTraits(this CardData t, params TraitStacks[] traits)
		{
			List<TraitStacks> val = new List<TraitStacks>();
			foreach (TraitStacks val2 in traits)
			{
				val.Add(val2);
			}
			t.traits = val;
			return t;
		}

		public static CardData SetStats(this CardData t, int? health = null, int? damage = null, int counter = 0)
		{
			return t.SetHealth(health).SetDamage(damage).SetCounter(counter);
		}

		public static CardData SetCounter(this CardData t, int counter)
		{
			t.counter = counter;
			return t;
		}

		public static CardData SetDamage(this CardData t, int? damage)
		{
			if (damage.HasValue)
			{
				t.hasAttack = true;
				t.damage = damage.Value;
			}
			return t;
		}

		public static CardData SetHealth(this CardData t, int? health)
		{
			if (health.HasValue)
			{
				t.hasHealth = true;
				t.hp = health.Value;
			}
			return t;
		}

		public static CardData SetSprites(this CardData t, string mainSprite, string backgroundSprite)
		{
			t.mainSprite = LoadSpriteFromCardPortraits(mainSprite);
			t.backgroundSprite = LoadSpriteFromCardPortraits(backgroundSprite);
			return t;
		}

		public static CardData SetIsUnit(this CardData t)
		{
			t.canBeHit = true;
			t.playType = (PlayType)2;
			t.canPlayOnBoard = true;
			return t;
		}

		public static CardData SetCardType(this CardData t, VanillaCardTypes cardType)
		{
			t.cardType = AddressableLoader.GetGroup<CardType>("CardType").Find((CardType type) => ((Object)type).name == cardType.ToString().Replace("VanillaCardTypes.", ""));
			return t;
		}

		public static CardData SetCardType(this CardData t, string cardTypeName)
		{
			t.cardType = AddressableLoader.GetGroup<CardType>("CardType").Find((CardType type) => ((Object)type).name == cardTypeName);
			return t;
		}

		public static CardData SetCanPlay(this CardData t, CanPlay canPlayFlags)
		{
			t.canPlayOnBoard = canPlayFlags.HasFlag(CanPlay.CanPlayOnBoard);
			t.canPlayOnEnemy = canPlayFlags.HasFlag(CanPlay.CanPlayOnEnemy);
			t.canPlayOnFriendly = canPlayFlags.HasFlag(CanPlay.CanPlayOnFriendly);
			t.canPlayOnHand = canPlayFlags.HasFlag(CanPlay.CanPlayOnHand);
			return t;
		}

		public static CardData SetItemUses(this CardData t, int amount)
		{
			t.uses = amount;
			return t;
		}

		public static CardData SetIsItem(this CardData t)
		{
			t.uses = 1;
			t.canBeHit = false;
			t.playType = (PlayType)1;
			t = t.SetCardType(VanillaCardTypes.Item);
			return t;
		}

		public static CardData SetTitle(this CardData t, string name)
		{
			t.titleKey = LocalizationHelper.FromId(LocalizationHelper.CreateLocalizedString(((Object)t).name + ".Title", name));
			return t;
		}

		public static CardData SetText(this CardData t, string text)
		{
			t.textKey = LocalizationHelper.FromId(LocalizationHelper.CreateLocalizedString(((Object)t).name + ".Text", text));
			return t;
		}

		public static CardData SetFlavour(this CardData t, string flavour)
		{
			t.flavourKey = LocalizationHelper.FromId(LocalizationHelper.CreateLocalizedString(((Object)t).name + ".Flavour", flavour));
			return t;
		}

		public static CardData CreateCardData(string modName, string cardName)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			string text = cardName;
			cardName = (cardName.StartsWith(modName) ? cardName : (modName + "." + cardName));
			if (modName == "")
			{
				cardName = text;
			}
			CardData val = null;
			CardData val2 = IArrayExt.ToList<CardData>((Il2CppArrayBase<CardData>)(object)((Il2CppObjectBase)Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<CardData>())).Cast<Il2CppReferenceArray<CardData>>())?.Find((CardData c) => !ExtensionMethods.IsNullOrDestroyed((Object)(object)c) && ((Object)c).name == cardName);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			val = ScriptableObject.CreateInstance<CardData>();
			val.titleKey = new LocalizedString();
			val.flavourKey = new LocalizedString();
			val.textKey = new LocalizedString();
			val.injuries = new List<StatusEffectStacks>();
			val.upgrades = new List<CardUpgradeData>();
			val.attackEffects = new Il2CppReferenceArray<StatusEffectStacks>(0L);
			val.startWithEffects = new Il2CppReferenceArray<StatusEffectStacks>(0L);
			val.traits = new List<TraitStacks>();
			val.createScripts = new Il2CppReferenceArray<CardScript>(0L);
			val = val.SetTargetMode(VanillaTargetModes.TargetModeBasic);
			((Object)val).name = cardName;
			val.cardType = AddressableLoader.GetGroup<CardType>("CardType")?.Find((CardType type) => !ExtensionMethods.IsNullOrDestroyed((Object)(object)type) && ((Object)type).name == "Friendly");
			val.backgroundSprite = LoadSpriteFromCardPortraits("CardPortraits\\FALLBACKBACKGROUNDSPRITE.png");
			val.mainSprite = LoadSpriteFromCardPortraits("CardPortraits\\FALLBACKMAINSPRITE.png");
			return val;
		}
	}
	public static class CardUpgradeAdder
	{
		public static event Action<int> OnAskForAddingCardUpgrades;

		public static CardUpgradeData ModifyFields(this CardUpgradeData t, Func<CardUpgradeData, CardUpgradeData> modifyFields)
		{
			t = modifyFields(t);
			return t;
		}

		public static CardUpgradeData SetText(this CardUpgradeData t, string text)
		{
			t.textKey = LocalizationHelper.FromId(LocalizationHelper.CreateLocalizedString(((Object)t).name + ".Text", text));
			return t;
		}

		public static CardUpgradeData SetTitle(this CardUpgradeData t, string title)
		{
			t.titleKey = LocalizationHelper.FromId(LocalizationHelper.CreateLocalizedString(((Object)t).name + ".Title", title));
			return t;
		}

		public static CardUpgradeData SetUpgradeType(this CardUpgradeData t, Type type)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			t.type = type;
			return t;
		}

		public static CardUpgradeData SetImage(this CardUpgradeData t, string sprite)
		{
			t.image = CardAdder.LoadSpriteFromCardPortraits(sprite);
			return t;
		}

		public static CardUpgradeData SetAttackEffects(this CardUpgradeData t, params StatusEffectStacks[] effect)
		{
			t.attackEffects = Il2CppReferenceArray<StatusEffectStacks>.op_Implicit(effect);
			return t;
		}

		public static CardUpgradeData SetStartWithEffects(this CardUpgradeData t, params StatusEffectStacks[] effect)
		{
			t.startWithEffectsApplied = new List<StatusEffectStacks>();
			foreach (StatusEffectStacks val in effect)
			{
				t.startWithEffectsApplied.Add(val);
			}
			return t;
		}

		public static CardUpgradeData SetTraits(this CardUpgradeData t, params TraitStacks[] traits)
		{
			List<TraitStacks> val = new List<TraitStacks>();
			foreach (TraitStacks val2 in traits)
			{
				val.Add(val2);
			}
			t.traitsAffected = val;
			return t;
		}

		public static CardUpgradeData RegisterCardUpgradeData(this CardUpgradeData t)
		{
			WildFrostAPIMod.GroupAdditions["CardUpgradeData"].Add((Object)(object)t);
			return t;
		}

		public static CardUpgradeData AddToPool(this CardUpgradeData t, params CardAdder.VanillaRewardPools[] rewardPools)
		{
			List<string> list = new List<string>();
			for (int i = 0; i < rewardPools.Length; i++)
			{
				CardAdder.VanillaRewardPools vanillaRewardPools = rewardPools[i];
				list.Add(vanillaRewardPools.ToString().Replace("VanillaRewardPools.", ""));
			}
			t = t.AddToPool(list.ToArray());
			return t;
		}

		public static CardUpgradeData AddToPool(this CardUpgradeData t, params string[] rewardPools)
		{
			Il2CppReferenceArray<Object> val = Object.FindObjectsOfTypeIncludingAssets(Il2CppType.Of<RewardPool>());
			foreach (string poolName in rewardPools)
			{
				RewardPool val2 = ((Il2CppObjectBase)IArrayExt.ToList<Object>((Il2CppArrayBase<Object>)(object)val).Find((Object a) => a.name == poolName)).Cast<RewardPool>();
				if (val2 != null)
				{
					val2.list?.Add((DataFile)(object)t);
				}
			}
			return t;
		}

		public static CardUpgradeData CreateCardUpgradeData(string modName, string cardName)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			CardUpgradeData val = ScriptableObject.CreateInstance<CardUpgradeData>();
			val.textKey = new LocalizedString();
			((Object)val).name = (cardName.StartsWith(modName) ? cardName : (modName + "." + cardName));
			if (modName == "")
			{
				((Object)val).name = cardName;
			}
			return val;
		}

		internal static void LaunchEvent()
		{
			if (WildFrostAPIMod.GroupAdditions["CardUpgradeData"].Count <= 0)
			{
				CardUpgradeAdder.OnAskForAddingCardUpgrades?.Invoke(0);
			}
		}
	}
	public static class IL2CPPHelpers
	{
		public static T Find<T>(this List<T> list, Predicate<T> p)
		{
			Enumerator<T> enumerator = list.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				if (p(current))
				{
					return current;
				}
			}
			return default(T);
		}
	}
	public static class JSONApi
	{
		public class JSONCardUpdateData
		{
			public string name;
		}

		public class JSONStatusEffectData
		{
			public string name;

			public int count;
		}

		public class JSONTraitData
		{
			public string name;

			public int count;
		}

		public class JSONCardData
		{
			public string portraitPath;

			public string backgroundPath;

			public string name;

			public string title;

			public int hp;

			public bool hasHealth;

			public int damage;

			public bool hasAttack;

			public int counter;

			public JSONCardUpdateData[] upgrades;

			public JSONStatusEffectData[] attackEffects;

			public JSONStatusEffectData[] startWithEffects;

			public JSONTraitData[] traits;

			public Dictionary<string, object> customData;

			public string[] pools;

			public string bloodProfile;

			public string idleAnimation;

			public string CardType;

			public bool IsItem;

			public bool CanPlayOnBoard;

			public bool CanPlayOnEnemy;

			public bool CanPlayOnFriendly;

			public bool CanPlayOnHand;

			public bool IsPet;
		}

		internal static void AddJSONCards(int unused)
		{
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Expected O, but got Unknown
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Expected O, but got Unknown
			JSONCardData jSONCardData = new JSONCardData();
			jSONCardData.portraitPath = "CardPortraits\\FALLBACKMAINSPRITE";
			jSONCardData.backgroundPath = "CardPortraits\\FALLBACKBACKGROUNDSPRITE";
			jSONCardData.name = "API.TemplateCard";
			jSONCardData.title = "Template Card";
			jSONCardData.hp = 1;
			jSONCardData.hasHealth = true;
			jSONCardData.damage = 1;
			jSONCardData.hasAttack = true;
			jSONCardData.counter = 1;
			jSONCardData.upgrades = new JSONCardUpdateData[1]
			{
				new JSONCardUpdateData
				{
					name = "Card Upgrade name"
				}
			};
			jSONCardData.attackEffects = new JSONStatusEffectData[1]
			{
				new JSONStatusEffectData
				{
					name = "Status effect name",
					count = 1
				}
			};
			jSONCardData.startWithEffects = new JSONStatusEffectData[1]
			{
				new JSONStatusEffectData
				{
					name = "Status effect name",
					count = 1
				}
			};
			jSONCardData.traits = new JSONTraitData[1]
			{
				new JSONTraitData
				{
					name = "Trait name",
					count = 1
				}
			};
			jSONCardData.customData = new Dictionary<string, object> { ["SomeData"] = true };
			jSONCardData.pools = new string[1] { "BasicItemPool" };
			jSONCardData.bloodProfile = "Blood Profile Normal";
			jSONCardData.idleAnimation = "SwayAnimationProfile";
			jSONCardData.CanPlayOnBoard = true;
			jSONCardData.CanPlayOnEnemy = true;
			jSONCardData.CanPlayOnFriendly = true;
			jSONCardData.CanPlayOnHand = true;
			jSONCardData.IsItem = true;
			jSONCardData.CardType = "Item";
			jSONCardData.IsPet = false;
			string contents = jSONCardData.ToJson();
			File.WriteAllText(WildFrostAPIMod.ModsFolder + "Template.json", contents);
			foreach (string item in Directory.EnumerateFiles(WildFrostAPIMod.ModsFolder, "*.json", SearchOption.AllDirectories))
			{
				if (item.EndsWith("Template.json") || item.EndsWith("manifest.json"))
				{
					continue;
				}
				string json = File.ReadAllText(item);
				JSONCardData jSONCardData2 = json.FromJson<JSONCardData>();
				((BasePlugin)WildFrostAPIMod.Instance).Log.LogInfo((object)jSONCardData2.name);
				List<StatusEffectStacks> val = new List<StatusEffectStacks>();
				JSONStatusEffectData[] attackEffects = jSONCardData2.attackEffects;
				foreach (JSONStatusEffectData jSONStatusEffectData in attackEffects)
				{
					StatusEffectStacks val2 = new StatusEffectStacks
					{
						count = jSONStatusEffectData.count,
						data = jSONStatusEffectData.name.StatusEffectData()
					};
					((BasePlugin)WildFrostAPIMod.Instance).Log.LogInfo((object)(jSONStatusEffectData.name + " " + jSONStatusEffectData.count + " added to json attack effects"));
					val.Add(val2);
				}
				List<StatusEffectStacks> val3 = new List<StatusEffectStacks>();
				JSONStatusEffectData[] startWithEffects = jSONCardData2.startWithEffects;
				foreach (JSONStatusEffectData jSONStatusEffectData2 in startWithEffects)
				{
					StatusEffectStacks val4 = new StatusEffectStacks
					{
						count = jSONStatusEffectData2.count,
						data = jSONStatusEffectData2.name.StatusEffectData()
					};
					val3.Add(val4);
				}
				List<CardUpgradeData> val5 = new List<CardUpgradeData>();
				JSONCardUpdateData[] upgrades = jSONCardData2.upgrades;
				foreach (JSONCardUpdateData jSONCardUpdateData in upgrades)
				{
					CardUpgradeData val6 = ((Il2CppObjectBase)AddressableLoader.groups["CardUpgradeData"].lookup[jSONCardUpdateData.name]).Cast<CardUpgradeData>();
					val5.Add(val6);
				}
				List<TraitStacks> val7 = new List<TraitStacks>();
				JSONTraitData[] traits = jSONCardData2.traits;
				foreach (JSONTraitData jSONTraitData in traits)
				{
					TraitStacks val8 = new TraitStacks
					{
						count = jSONTraitData.count,
						data = jSONTraitData.name.TraitData()
					};
					val7.Add(val8);
				}
				CardData val9 = CardAdder.CreateCardData("", jSONCardData2.name).SetStats(jSONCardData2.hasHealth ? new int?(jSONCardData2.hp) : null, jSONCardData2.hasAttack ? new int?(jSONCardData2.damage) : null, jSONCardData2.counter).SetSprites(jSONCardData2.portraitPath, jSONCardData2.backgroundPath)
					.SetTitle(jSONCardData2.title)
					.SetAttackEffects(Il2CppArrayBase<StatusEffectStacks>.op_Implicit(val.ToArray()))
					.SetStartWithEffects(Il2CppArrayBase<StatusEffectStacks>.op_Implicit(val3.ToArray()))
					.SetUpgrades(val5)
					.SetTraits(Il2CppArrayBase<TraitStacks>.op_Implicit(val7.ToArray()))
					.AddToPool(jSONCardData2.pools)
					.SetBloodProfile(jSONCardData2.bloodProfile)
					.SetIdleAnimationProfile(jSONCardData2.idleAnimation);
				if (jSONCardData2.customData != null)
				{
					foreach (KeyValuePair<string, object> customDatum in jSONCardData2.customData)
					{
						val9.SetCustomData(customDatum.Key, (Object)customDatum.Value);
					}
				}
				val9.canPlayOnBoard = jSONCardData2.CanPlayOnBoard;
				val9.canPlayOnEnemy = jSONCardData2.CanPlayOnEnemy;
				val9.canPlayOnFriendly = jSONCardData2.Can