using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AllTheSigils.Artwork;
using AllTheSigils.Voids_work.Cards;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DigitalRuby.LightningBolt;
using DiskCardGame;
using GBC;
using HarmonyLib;
using InscryptionAPI.Card;
using InscryptionAPI.CardCosts;
using InscryptionAPI.Guid;
using InscryptionAPI.Saves;
using InscryptionAPI.Triggers;
using Pixelplacement;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("AllTheSigils")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A giant custom sigil library.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AllTheSigils")]
[assembly: AssemblyTitle("AllTheSigils")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace AllTheSigils
{
	[BepInPlugin("ATS", "AllTheSigils", "3.0.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public class TurnIntoChickenOpp : AbilityBehaviour
		{
			public static Ability ability;

			private int lastShotTurn = -1;

			private PlayableCard lastShotCard;

			public override Ability Ability => ((AbilityBehaviour)this).Ability;

			public override int Priority => -1;

			public override bool RespondsToOtherCardResolve(PlayableCard otherCard)
			{
				return RespondsToTrigger(otherCard);
			}

			public override IEnumerator OnOtherCardResolve(PlayableCard otherCard)
			{
				yield return FireAtOpposingSlot(otherCard);
			}

			public override bool RespondsToOtherCardAssignedToSlot(PlayableCard otherCard)
			{
				return RespondsToTrigger(otherCard);
			}

			public override IEnumerator OnOtherCardAssignedToSlot(PlayableCard otherCard)
			{
				yield return FireAtOpposingSlot(otherCard);
			}

			private bool RespondsToTrigger(PlayableCard otherCard)
			{
				return !((AbilityBehaviour)this).Card.Dead && !otherCard.Dead && (Object)(object)otherCard.Slot == (Object)(object)((AbilityBehaviour)this).Card.Slot.opposingSlot;
			}

			private IEnumerator FireAtOpposingSlot(PlayableCard otherCard)
			{
				if ((Object)(object)otherCard != (Object)(object)lastShotCard || Singleton<TurnManager>.Instance.TurnNumber != lastShotTurn)
				{
					lastShotCard = otherCard;
					lastShotTurn = Singleton<TurnManager>.Instance.TurnNumber;
					Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
					yield return (object)new WaitForSeconds(0.25f);
					if ((Object)(object)otherCard != (Object)null && !otherCard.Dead)
					{
						CardInfo cardByName = CardLoader.GetCardByName("AP_Chicken");
						yield return otherCard.TransformIntoCard(cardByName, (Action)null, (Action)null);
					}
					yield return ((AbilityBehaviour)this).LearnAbility(0.5f);
					Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
				}
			}
		}

		public class TurnIntoChickenLooseCannon : AbilityBehaviour
		{
			public static Ability ability;

			public override Ability Ability => ability;

			public override bool RespondsToTurnEnd(bool playerTurnEnd)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return ((AbilityBehaviour)this).Card.HasAbility(ability);
			}

			public override IEnumerator OnTurnEnd(bool playerTurnEnd)
			{
				PlayableCard card = ((AbilityBehaviour)this).Card;
				List<CardSlot> allSlots = Singleton<BoardManager>.Instance.AllSlots;
				List<PlayableCard> list = new List<PlayableCard>();
				for (int i = 0; i < allSlots.Count; i++)
				{
					if ((Object)(object)allSlots[i].Card != (Object)null)
					{
						list.Add(allSlots[i].Card);
					}
				}
				PlayableCard target = list[Random.Range(0, list.Count)];
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				((Card)card).Anim.LightNegationEffect();
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				CardInfo cardByName = CardLoader.GetCardByName("AP_Chicken");
				yield return target.TransformIntoCard(cardByName, (Action)null, (Action)null);
				yield return ((AbilityBehaviour)this).LearnAbility(0.25f);
				Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
			}
		}

		public class TurnIntoChickenEnemyOnly : AbilityBehaviour
		{
			public static Ability ability;

			public override Ability Ability => ability;

			public override bool RespondsToTurnEnd(bool playerTurnEnd)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return ((AbilityBehaviour)this).Card.HasAbility(ability);
			}

			public override IEnumerator OnTurnEnd(bool playerTurnEnd)
			{
				PlayableCard card = ((AbilityBehaviour)this).Card;
				List<CardSlot> opponentSlots = Singleton<BoardManager>.Instance.opponentSlots;
				List<PlayableCard> list = new List<PlayableCard>();
				for (int i = 0; i < opponentSlots.Count; i++)
				{
					if ((Object)(object)opponentSlots[i].Card != (Object)null)
					{
						list.Add(opponentSlots[i].Card);
					}
				}
				PlayableCard target = list[Random.Range(0, list.Count)];
				if ((Object)(object)target != (Object)null)
				{
					Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
					((Card)card).Anim.LightNegationEffect();
					yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
					CardInfo cardByName = CardLoader.GetCardByName("AP_Chicken");
					yield return target.TransformIntoCard(cardByName, (Action)null, (Action)null);
					yield return ((AbilityBehaviour)this).LearnAbility(0.25f);
					Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
				}
			}
		}

		public class EatChickens : AbilityBehaviour
		{
			public static Ability ability;

			private CardModificationInfo mod;

			public override Ability Ability => ability;

			private void Start()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				mod = new CardModificationInfo();
				mod.nonCopyable = true;
				mod.singletonId = "increaseATKincreaseHealth";
				mod.attackAdjustment = 0;
				mod.healthAdjustment = 0;
				((AbilityBehaviour)this).Card.AddTemporaryMod(mod);
			}

			public override bool RespondsToTurnEnd(bool playerTurnEnd)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				return ((AbilityBehaviour)this).Card.HasAbility(ability);
			}

			public override IEnumerator OnTurnEnd(bool playerTurnEnd)
			{
				PlayableCard card = ((AbilityBehaviour)this).Card;
				List<CardSlot> allSlots = Singleton<BoardManager>.Instance.AllSlots;
				List<PlayableCard> list = new List<PlayableCard>();
				for (int i = 0; i < allSlots.Count; i++)
				{
					if ((Object)(object)allSlots[i].Card != (Object)null && allSlots[i].Card.HasAbility(JustChicken.ability))
					{
						list.Add(allSlots[i].Card);
					}
				}
				PlayableCard target = list[Random.Range(0, list.Count)];
				if ((Object)(object)target != (Object)null)
				{
					Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
					((Card)card).Anim.LightNegationEffect();
					yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
					CardModificationInfo obj = mod;
					obj.attackAdjustment += ((Card)target).Info.Health;
					CardModificationInfo obj2 = mod;
					obj2.healthAdjustment += ((Card)target).Info.Attack;
					((AbilityBehaviour)this).Card.OnStatsChanged();
					target.TakeDamage(1024, card);
					target.Die(false, card, false);
					yield return ((AbilityBehaviour)this).LearnAbility(0.25f);
					Singleton<ViewManager>.Instance.Controller.LockState = (ViewLockState)0;
				}
			}
		}

		public class JustChicken : AbilityBehaviour
		{
			public static Ability ability;

			public override Ability Ability => ability;
		}

		public abstract class ActivatedLatch : ActivatedAbilityBehaviour
		{
			public static Ability ability;

			public override Ability Ability => ability;

			protected abstract Ability LatchAbility { get; }

			public override IEnumerator Activate()
			{
				if (SceneLoader.ActiveSceneName == "Part1_Cabin")
				{
					List<CardSlot> validTargets2 = Singleton<BoardManager>.Instance.AllSlotsCopy;
					validTargets2.RemoveAll((CardSlot x) => (Object)(object)x.Card == (Object)null || x.Card.Dead || CardHasLatchMod(x.Card) || (Object)(object)x.Card == (Object)(object)((AbilityBehaviour)this).Card);
					if (validTargets2.Count <= 0)
					{
						yield break;
					}
					Singleton<ViewManager>.Instance.SwitchToView((View)4, false, false);
					((Card)((AbilityBehaviour)this).Card).Anim.PlayHitAnimation();
					yield return (object)new WaitForSeconds(0.1f);
					CardAnimationController cardAnim2 = ((Card)((AbilityBehaviour)this).Card).Anim;
					GameObject LatchPreParent = new GameObject();
					((Object)LatchPreParent).name = "LatchParent";
					LatchPreParent.transform.position = ((Component)cardAnim2).transform.position;
					LatchPreParent.gameObject.transform.parent = ((Component)cardAnim2).transform;
					Transform Latchparent = LatchPreParent.transform;
					GameObject claw2 = Object.Instantiate<GameObject>(anthonyClawPrefab, Latchparent);
					CardSlot selectedSlot2 = null;
					if (((AbilityBehaviour)this).Card.OpponentCard)
					{
						yield return (object)new WaitForSeconds(0.3f);
						yield return AISelectTarget(validTargets2, delegate(CardSlot s)
						{
							selectedSlot2 = s;
						});
						if ((Object)(object)selectedSlot2 != (Object)null && (Object)(object)selectedSlot2.Card != (Object)null)
						{
							AimWeaponAnim(((Component)Latchparent).gameObject, ((Component)selectedSlot2).transform.position);
							yield return (object)new WaitForSeconds(0.3f);
						}
					}
					else
					{
						List<CardSlot> allSlotsCopy2 = Singleton<BoardManager>.Instance.AllSlotsCopy;
						allSlotsCopy2.Remove(((AbilityBehaviour)this).Card.Slot);
						yield return Singleton<BoardManager>.Instance.ChooseTarget(allSlotsCopy2, validTargets2, (Action<CardSlot>)delegate(CardSlot s)
						{
							selectedSlot2 = s;
						}, (Action<CardSlot>)OnInvalidTarget, (Action<CardSlot>)delegate(CardSlot s)
						{
							//IL_0023: Unknown result type (might be due to invalid IL or missing references)
							if ((Object)(object)s.Card != (Object)null)
							{
								AimWeaponAnim(((Component)Latchparent).gameObject, ((Component)s).transform.position);
							}
						}, (Func<bool>)null, (CursorType)16);
					}
					claw2.SetActive(true);
					CustomCoroutine.FlickerSequence((Action)delegate
					{
						claw2.SetActive(true);
					}, (Action)delegate
					{
						claw2.SetActive(false);
					}, true, false, 0.05f, 2, (Action)null);
					if ((Object)(object)selectedSlot2 != (Object)null && (Object)(object)selectedSlot2.Card != (Object)null)
					{
						CardModificationInfo cardModificationInfo2 = new CardModificationInfo(LatchAbility);
						cardModificationInfo2.fromCardMerge = true;
						cardModificationInfo2.fromLatch = true;
						if (((Object)((Card)selectedSlot2.Card).Info).name == "!DEATHCARD_BASE")
						{
							selectedSlot2.Card.AddTemporaryMod(cardModificationInfo2);
						}
						else
						{
							object obj = ((Card)selectedSlot2.Card).Info.Clone();
							CardInfo targetCardInfo = (CardInfo)((obj is CardInfo) ? obj : null);
							targetCardInfo.Mods.Add(cardModificationInfo2);
							((Card)selectedSlot2.Card).SetInfo(targetCardInfo);
						}
						((Card)selectedSlot2.Card).Anim.PlayTransformAnimation();
						OnSuccessfullyLatched(selectedSlot2.Card);
						yield return (object)new WaitForSeconds(0.75f);
						yield return ((AbilityBehaviour)this).LearnAbility(0f);
					}
					yield break;
				}
				List<CardSlot> validTargets = Singleton<BoardManager>.Instance.AllSlotsCopy;
				validTargets.RemoveAll((CardSlot x) => (Object)(object)x.Card == (Object)null || x.Card.Dead || CardHasLatchMod(x.Card) || (Object)(object)x.Card == (Object)(object)((AbilityBehaviour)this).Card);
				if (validTargets.Count <= 0)
				{
					yield break;
				}
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, false);
				((Card)((AbilityBehaviour)this).Card).Anim.PlayHitAnimation();
				yield return (object)new WaitForSeconds(0.1f);
				DiskCardAnimationController cardAnim = default(DiskCardAnimationController);
				ref DiskCardAnimationController reference = ref cardAnim;
				CardAnimationController anim = ((Card)((AbilityBehaviour)this).Card).Anim;
				reference = (DiskCardAnimationController)(object)((anim is DiskCardAnimationController) ? anim : null);
				GameObject claw = Object.Instantiate<GameObject>(anthonyClawPrefab, ((Component)cardAnim.WeaponParent).transform);
				CardSlot selectedSlot = null;
				if (((AbilityBehaviour)this).Card.OpponentCard)
				{
					yield return (object)new WaitForSeconds(0.3f);
					yield return AISelectTarget(validTargets, delegate(CardSlot s)
					{
						selectedSlot = s;
					});
					if ((Object)(object)selectedSlot != (Object)null && (Object)(object)selectedSlot.Card != (Object)null)
					{
						cardAnim.AimWeaponAnim(((Component)selectedSlot).transform.position);
						yield return (object)new WaitForSeconds(0.3f);
					}
				}
				else
				{
					List<CardSlot> allSlotsCopy = Singleton<BoardManager>.Instance.AllSlotsCopy;
					allSlotsCopy.Remove(((AbilityBehaviour)this).Card.Slot);
					yield return Singleton<BoardManager>.Instance.ChooseTarget(allSlotsCopy, validTargets, (Action<CardSlot>)delegate(CardSlot s)
					{
						selectedSlot = s;
					}, (Action<CardSlot>)OnInvalidTarget, (Action<CardSlot>)delegate(CardSlot s)
					{
						//IL_001e: Unknown result type (might be due to invalid IL or missing references)
						if ((Object)(object)s.Card != (Object)null)
						{
							cardAnim.AimWeaponAnim(((Component)s).transform.position);
						}
					}, (Func<bool>)null, (CursorType)16);
				}
				CustomCoroutine.FlickerSequence((Action)delegate
				{
					claw.SetActive(true);
				}, (Action)delegate
				{
					claw.SetActive(false);
				}, true, false, 0.05f, 2, (Action)null);
				if ((Object)(object)selectedSlot != (Object)null && (Object)(object)selectedSlot.Card != (Object)null)
				{
					CardModificationInfo cardModificationInfo = new CardModificationInfo(LatchAbility);
					cardModificationInfo.fromLatch = true;
					((Card)selectedSlot.Card).Anim.ShowLatchAbility();
					selectedSlot.Card.AddTemporaryMod(cardModificationInfo);
					OnSuccessfullyLatched(selectedSlot.Card);
					yield return (object)new WaitForSeconds(0.75f);
					yield return ((AbilityBehaviour)this).LearnAbility(0f);
				}
			}

			protected virtual void OnSuccessfullyLatched(PlayableCard target)
			{
			}

			private IEnumerator AISelectTarget(List<CardSlot> validTargets, Action<CardSlot> chosenCallback)
			{
				if (validTargets.Count > 0)
				{
					bool positiveAbility = AbilitiesUtil.GetInfo(LatchAbility).PositiveEffect;
					validTargets.Sort((CardSlot a, CardSlot b) => AIEvaluateTarget(b.Card, positiveAbility) - AIEvaluateTarget(a.Card, positiveAbility));
					chosenCallback(validTargets[0]);
					yield return (object)new WaitForSeconds(0.1f);
				}
				else
				{
					((Card)((AbilityBehaviour)this).Card).Anim.LightNegationEffect();
					yield return (object)new WaitForSeconds(0.2f);
				}
			}

			private int AIEvaluateTarget(PlayableCard card, bool positiveEffect)
			{
				int num = card.PowerLevel;
				if (((Card)card).Info.HasTrait((Trait)12))
				{
					num = 10 * ((!positiveEffect) ? 1 : (-1));
				}
				if (card.OpponentCard == positiveEffect)
				{
					num += 1000;
				}
				return num;
			}

			private void OnInvalidTarget(CardSlot slot)
			{
				if ((Object)(object)slot.Card != (Object)null && CardHasLatchMod(slot.Card) && !Singleton<TextDisplayer>.Instance.Displaying)
				{
					((MonoBehaviour)this).StartCoroutine(Singleton<TextDisplayer>.Instance.ShowThenClear("It's already latched...", 2.5f, 0f, (Emotion)2, (LetterAnimation)0, (Speaker)0, (string[])null));
				}
			}

			private bool CardHasLatchMod(PlayableCard card)
			{
				return card.TemporaryMods.Exists((CardModificationInfo m) => m.fromLatch);
			}
		}

		public class ActivatedLatchNanoShield : ActivatedLatch
		{
			public new static Ability ability;

			public override Ability Ability => ability;

			public override int EnergyCost => 1;

			public override int BonesCost => 2;

			protected override Ability LatchAbility => (Ability)54;

			protected override void OnSuccessfullyLatched(PlayableCard target)
			{
				target.ResetShield();
				((Card)((AbilityBehaviour)this).Card).SetCardbackSubmerged();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(true, false);
			}

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(false, false);
				((AbilityBehaviour)this).Card.UpdateFaceUpOnBoardEffects();
				yield return (object)new WaitForSeconds(0.3f);
			}
		}

		public class ActivatedLatchReach : ActivatedLatch
		{
			public new static Ability ability;

			public override Ability Ability => ability;

			public override int EnergyCost => 2;

			protected override Ability LatchAbility => (Ability)23;

			protected override void OnSuccessfullyLatched(PlayableCard target)
			{
				((Card)((AbilityBehaviour)this).Card).SetCardbackSubmerged();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(true, false);
			}

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(false, false);
				((AbilityBehaviour)this).Card.UpdateFaceUpOnBoardEffects();
				yield return (object)new WaitForSeconds(0.3f);
			}
		}

		public class ActivatedLatchBrittle : ActivatedLatch
		{
			public new static Ability ability;

			public override Ability Ability => ability;

			public override int EnergyCost => 1;

			protected override Ability LatchAbility => (Ability)35;

			protected override void OnSuccessfullyLatched(PlayableCard target)
			{
				((Card)((AbilityBehaviour)this).Card).SetCardbackSubmerged();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(true, false);
			}

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(false, false);
				((AbilityBehaviour)this).Card.UpdateFaceUpOnBoardEffects();
				yield return (object)new WaitForSeconds(0.3f);
			}
		}

		public class ActivatedLatchExplodeOnDeath : ActivatedLatch
		{
			public new static Ability ability;

			public override Ability Ability => ability;

			public override int EnergyCost => 2;

			protected override Ability LatchAbility => (Ability)52;

			protected override void OnSuccessfullyLatched(PlayableCard target)
			{
				((Card)((AbilityBehaviour)this).Card).SetCardbackSubmerged();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(true, false);
			}

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((Card)((AbilityBehaviour)this).Card).SetFaceDown(false, false);
				((AbilityBehaviour)this).Card.UpdateFaceUpOnBoardEffects();
				yield return (object)new WaitForSeconds(0.3f);
			}
		}

		public class IncreasePowerDecreaseHealth : AbilityBehaviour
		{
			public static Ability ability;

			private CardModificationInfo mod;

			public override Ability Ability => ability;

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			private void Start()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				int health = ((Card)((AbilityBehaviour)this).Card).Info.Health;
				mod = new CardModificationInfo();
				mod.nonCopyable = true;
				mod.singletonId = "increaseATKtakeDamage";
				mod.attackAdjustment = 0;
				((AbilityBehaviour)this).Card.AddTemporaryMod(mod);
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((AbilityBehaviour)this).Card.TakeDamage(1, (PlayableCard)null);
				((Card)((AbilityBehaviour)this).Card).Anim.StrongNegationEffect();
				CardModificationInfo obj = mod;
				obj.attackAdjustment++;
				((AbilityBehaviour)this).Card.OnStatsChanged();
				yield return (object)new WaitForSeconds(0.25f);
				yield return ((AbilityBehaviour)this).LearnAbility(0.25f);
			}
		}

		public class DecreasePowerIncreaseHealth : AbilityBehaviour
		{
			public static Ability ability;

			private CardModificationInfo mod;

			public override Ability Ability => ability;

			public override bool RespondsToUpkeep(bool playerUpkeep)
			{
				return ((AbilityBehaviour)this).Card.OpponentCard != playerUpkeep;
			}

			private void Start()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				int health = ((Card)((AbilityBehaviour)this).Card).Info.Health;
				mod = new CardModificationInfo();
				mod.nonCopyable = true;
				mod.singletonId = "increaseHPdecreaseATK";
				mod.healthAdjustment = 0;
				mod.attackAdjustment = 0;
				((AbilityBehaviour)this).Card.AddTemporaryMod(mod);
			}

			public override IEnumerator OnUpkeep(bool playerUpkeep)
			{
				Singleton<ViewManager>.Instance.SwitchToView((View)4, false, true);
				yield return (object)new WaitForSeconds(0.15f);
				yield return ((AbilityBehaviour)this).PreSuccessfulTriggerSequence();
				((Card)((AbilityBehaviour)this).Card).Anim.StrongNegationEffect();
				CardModificationInfo obj = mod;
				obj.healthAdjustment++;
				CardModificationInfo obj2 = mod;
				obj2.attackAdjustment--;
				((AbilityBehaviour)this).Card.OnStatsChanged();
				yield return (object)new WaitForSeconds(0.25f);
				yield return ((AbilityBehaviour)this).LearnAbility(0.25f);
			}
		}

		public class ChangePortraitWhenMerged : SpecialCardBehaviour
		{
			public static SpecialTriggeredAbility ability;

			public void Update()
			{
				if (((SpecialCardBehaviour)this).Card.Info.HasModFromCardMerge() && (Object)(object)((SpecialCardBehaviour)this).Card.RenderInfo.portraitOverride != (Object)(object)((SpecialCardBehaviour)this).Card.Info.alternatePortrait)
				{
					((SpecialCardBehaviour)this).Card.RenderInfo.portraitOverride = ((SpecialCardBehaviour)this).Card.Info.alternatePortrait;
					((SpecialCardBehaviour)this).Card.RenderCard();
				}
			}
		}

		internal static ConfigEntry<bool> configAcidTrail;

		internal static ConfigEntry<bool> configAgile;

		internal static ConfigEntry<bool> configAppetizing;

		internal static ConfigEntry<bool> configBloodGuzzler;

		internal static ConfigEntry<bool> configBombardier;

		internal static ConfigEntry<bool> configBurning;

		internal static ConfigEntry<bool> configConsumer;

		internal static ConfigEntry<bool> configCowardly;

		internal static ConfigEntry<bool> configDeathburst;

		internal static ConfigEntry<bool> configMultiStrike;

		internal static ConfigEntry<bool> configDying;

		internal static ConfigEntry<bool> configRecoil;

		internal static ConfigEntry<bool> configParalysis;

		internal static ConfigEntry<bool> configElectric;

		internal static ConfigEntry<bool> configFamiliar;

		internal static ConfigEntry<bool> configLeech;

		internal static ConfigEntry<bool> configPossessor;

		internal static ConfigEntry<bool> configPrideful;

		internal static ConfigEntry<bool> configRegen;

		internal static ConfigEntry<bool> configResistant;

		internal static ConfigEntry<bool> configSickness;

		internal static ConfigEntry<bool> configThickShell;

		internal static ConfigEntry<bool> configThief;

		internal static ConfigEntry<bool> configToxin;

		internal static ConfigEntry<bool> configTrample;

		internal static ConfigEntry<bool> configVicious;

		internal static ConfigEntry<bool> configHammerBlock;

		public const string PluginGuid = "ATS";

		public const string OldLilyPluginGuid = "org.memez4life.inscryption.customsigils";

		public const string OldVoidPluginGuid = "extraVoid.inscryption.voidSigils";

		public const string OldAnthonyPluginGuid = "AnthonyPython.inscryption.AnthonysSigils";

		public static List<string> OldPluginGuids = new List<string> { "org.memez4life.inscryption.customsigils", "extraVoid.inscryption.voidSigils", "AnthonyPython.inscryption.AnthonysSigils" };

		private const string PluginName = "AllTheSigils";

		private const string PluginVersion = "3.0.1";

		public static string Directory;

		internal static ManualLogSource Log;

		public static Dictionary<Ability, Tuple<string, string>> SigilWikiInfos = new Dictionary<Ability, Tuple<string, string>>();

		public static Dictionary<Ability, string> NewSigilVersions = new Dictionary<Ability, string>();

		public const bool GenerateWiki = false;

		public static GameObject anthonyClawPrefab;

		public void AddConfigs()
		{
			configAcidTrail = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Acid Trail", true, "Should Leshy have this?");
			configAgile = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Agile", true, "Should Leshy have this?");
			configBloodGuzzler = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "BloodGuzzler", true, "Should Leshy have this?");
			configConsumer = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Consumer", true, "Should Leshy have this?");
			configDeathburst = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Deathburst", true, "Should Leshy have this?");
			configElectric = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Electric", true, "Should Leshy have this?");
			configMultiStrike = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "MultiStrike", true, "Should Leshy have this?");
			configFamiliar = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Familiar", true, "Should Leshy have this?");
			configLeech = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Leech", true, "Should Leshy have this?");
			configPossessor = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Possessor", true, "Should Leshy have this?");
			configRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Regen 1", true, "Should Leshy have this?");
			configResistant = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Resistant", true, "Should Leshy have this?");
			configThickShell = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Thick Shell", true, "Should Leshy have this?");
			configThief = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Thief", true, "Should Leshy have this?");
			configToxin = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Toxins (all of them)", true, "Should Leshy have this?");
			configTrample = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Trample", true, "Should Leshy have this?");
			configVicious = ((BaseUnityPlugin)this).Config.Bind<bool>("Good Sigil", "Vicious", true, "Should Leshy have this?");
			configAppetizing = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Appetizing", true, "Should Leshy have this?");
			configBurning = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Burning", true, "Should Leshy have this?");
			configCowardly = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Cowardly", true, "Should Leshy have this?");
			configDying = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Dying", true, "Should Leshy have this?");
			configParalysis = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Paralysis", true, "Should Leshy have this?");
			configRecoil = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Recoil", true, "Should Leshy have this?");
			configPrideful = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Prideful", true, "Should Leshy have this?");
			configSickness = ((BaseUnityPlugin)this).Config.Bind<bool>("Bad Sigil", "Sickness", true, "Should Leshy have this?");
			configBombardier = ((BaseUnityPlugin)this).Config.Bind<bool>("Chaos Sigil", "Bombardier", true, "Should Leshy have this?");
			configHammerBlock = ((BaseUnityPlugin)this).Config.Bind<bool>("Hammer Block", "Pathetic Sacrifice", true, "Should the sigil pathetic sacrifice be invalid for hammering? Due to the intent being it is stuck on your board. default is true.");
		}

		private void Awake()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded AllTheSigils!");
			Log = ((BaseUnityPlugin)this).Logger;
			AddConfigs();
			Harmony val = new Harmony("ATS");
			val.PatchAll();
			Directory = ((BaseUnityPlugin)this).Info.Location;
			AddBond();
			AddShort();
			AddTribe_Attack();
			AddTribe_Health();
			AddBi_Blood();
			AddQuadra_Blood();
			AddImbuing();
			AddHydra();
			AddFight_Activated();
			AddPicky();
			AddFearful();
			AddTwoDeathBones();
			AddThreeDeathBones();
			AddFiveDeathBones();
			AddSixDeathBones();
			AddOneSummonBones();
			AddTwoSummonBones();
			AddThreeSummonBones();
			AddHost();
			AddSpawner();
			AddLauncher();
			AddShape_Shifter();
			AddDraw_Side_Deck_OnSummon();
			AddBait();
			AddLinguist();
			AddAll_Seeing();
			AddBlood_Shifter();
			AddAsleep();
			AddSong_Of_Sleep();
			AddWarper();
			AddRushing_March();
			AddWild_Hunger();
			AddRight_Slash();
			AddLeft_Slash();
			AddDouble_Slash();
			AddPuppets_Gift();
			AddInstakill();
			Acid_Puddle.AddCard();
			Jackalope.AddCard();
			AddAbundance();
			AddAcidTrail();
			AddAntler();
			AddAgile();
			AddAmbush();
			AddBlight();
			AddBlindingStrike();
			AddBloodGrowth();
			AddBloodGuzzler();
			AddBodyguard();
			AddBombardier();
			AddBonePicker();
			AddBoneless();
			AddBoneShard();
			AddBox();
			AddBroken();
			AddBurning();
			AddCaustic();
			addCoinFinder();
			AddConsumer();
			AddCoward();
			AddDeadlyWaters();
			AddDeathburst();
			AddDesperation();
			AddDiseaseAbsorbtion();
			AddDiveBones();
			AddDiveEnergy();
			AddDrawBlood();
			AddDrawBone();
			AddDrawIce();
			AddDrawJack();
			AddDrawStrafe();
			AddDwarf();
			AddDying();
			AddEletric();
			AddEnforcer();
			AddEnrage();
			AddEntomophage();
			AddFamiliar();
			AddFireStarter();
			AddFishHook();
			AddFrightful();
			AddGiant();
			AddGrazing();
			AddGripper();
			AddHaste();
			AddHasteful();
			AddHerd();
			AddHighTide();
			AddInjured();
			AddHourglass();
			AddLeech();
			AddLeadBones();
			AddLeadEnergy();
			AddLifeStatsUp();
			AddLowTide();
			AddFisher();
			AddManeuver();
			AddMedic();
			AddMidas();
			AddDoubleAttack();
			AddNutritious();
			AddOpportunist();
			AddParalise();
			AddPathetic();
			AddPierce();
			AddPoisonous();
			AddPossessor();
			AddPossessorPowerful();
			AddMovingPowerUp();
			AddPredator();
			AddPrideful();
			AddProtector();
			AddRam();
			AddRandomStrafe();
			AddBlind();
			AddRecoil();
			AddRegenFull();
			AddRegen1();
			AddRegen2();
			AddRegen3();
			AddRepellant();
			AddResistant();
			AddRetaliate();
			AddSchooling();
			AddScissors();
			AddSickness();
			AddSluggish();
			AddStampede();
			AddStrongWind();
			AddSubmergedAmbush();
			AddSwallower();
			AddTakeOffBones();
			AddTakeOffEnergy();
			AddThickShell();
			AddThief();
			AddToothBargain();
			AddToothPuller();
			AddToothShard();
			AddToxin();
			AddToxinStrength();
			AddToxinVigor();
			AddToxinDeadly();
			AddToxinSickly();
			AddTrample();
			AddTransient();
			AddTribalAlly();
			AddTribalTutor();
			addTurbulentWaters();
			AddStrafePowerUp();
			AddVicious();
			AddWithering();
			AddZapper();
			AddSticky();
			anthonyClawPrefab = ResourceBank.Get<GameObject>("Prefabs/Cards/SpecificCardModels/LatchClaw");
			AddActivactedNanoShield();
			AddActivactedBrittle();
			AddActivactedExplodeOnDeath();
			AddActivactedReach();
			AddDecreasePowerIncreaseHealth();
			AddTransformChickenLooseCannon();
			AddTransformChickenEnemyOnly();
			AddEatChicken();
			AddChicken();
			AddChickenCard();
			AddMount();
			AddParasite();
			AddHermit();
			AddDraw_Energy();
			AddDraw_Mox();
			AddDraw_Cost();
			AddHyped();
			AddResourceful();
			AddHoodini();
			AddInaccurate();
			AddDrunk();
			AddUnderdog();
			AddHoming();
			AddLullaby();
			AddNurse();
			AddMedical_Aid();
			AddSympathetic();
			AddArmoured();
			AddFrightened();
			AddTerrified();
			AddAlternating_Scratch();
			AddChoreography();
			AddChangePortraitWhenMerged();
			bool flag = false;
			AddTemporarySigils();
		}

		public void Start()
		{
			ReplaceNewSigilsOnCards();
		}

		public void WriteSigilPartOfTheWikiToFileInPluginDirectory()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Wiki/");
			if (!System.IO.Directory.Exists(text))
			{
				System.IO.Directory.CreateDirectory(text);
			}
			string text2 = "## Sigils\n\n<details>\n<summary>List of Sigils (Click to Expand)</summary>\n\n|Icon|Sigil Name|Power Level|Description|Notes|\n|-|:-:|:-:|:-:|:-:|";
			string text3 = "\n</details>";
			string text4 = "";
			string text5 = "https://raw.githubusercontent.com/Memez4Life7/AllTheSigils/master/Artwork";
			foreach (AbilityInfo allAbilityInfo in AbilityManager.AllAbilityInfos)
			{
				string sigilGuid = GetSigilGuid(allAbilityInfo.ability);
				if (OldPluginGuids.Contains(sigilGuid) || sigilGuid == "ATS")
				{
					string text6 = "";
					switch (sigilGuid)
					{
					case "org.memez4life.inscryption.customsigils":
						text6 = "Lily/Act1";
						break;
					case "extraVoid.inscryption.voidSigils":
						text6 = "Void_Merged";
						break;
					case "AnthonyPython.inscryption.AnthonysSigils":
						text6 = "Anthony";
						break;
					case "ATS":
						text6 = "ATS/Act1";
						break;
					}
					string text7 = "";
					text7 = ((!SigilWikiInfos.TryGetValue(allAbilityInfo.ability, out var value)) ? (text5 + "/Lily/Act1/placeholder.png") : (text5 + "/" + text6 + "/" + value.Item1 + ".png"));
					string rulebookName = allAbilityInfo.rulebookName;
					string text8 = allAbilityInfo.powerLevel.ToString();
					string rulebookDescription = allAbilityInfo.rulebookDescription;
					text4 = text4 + "\n|<img align=\"center\" src=\"" + text7 + "\">|**" + rulebookName + "**|" + text8 + "|" + rulebookDescription + "|" + value.Item2 + "|";
				}
			}
			string contents = text2 + text4 + "\n" + text3;
			File.WriteAllText(Path.Combine(text, "wiki.txt"), contents);
			Log.LogWarning((object)("FINISHED WRITING WIKI TEXT TO:\n" + text + "wiki.txt"));
		}

		public void AddTemporarySigils()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			foreach (AbilityInfo allAbilityInfo in AbilityManager.AllAbilityInfos)
			{
				string sigilGuid = GetSigilGuid(allAbilityInfo.ability);
				if (OldPluginGuids.Contains(sigilGuid))
				{
					AbilityInfo val = AbilityManager.New("ATS", allAbilityInfo.rulebookName, allAbilityInfo.rulebookDescription, typeof(EmptySigil), (Texture)(object)GetTextureLily("placeholder"));
					NewSigilVersions.Add(val.ability, sigilGuid);
				}
			}
		}

		public void ReplaceNewSigilsOnCards()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			List<CardInfo> allData = ScriptableObjectLoader<CardInfo>.AllData;
			for (int i = 0; i < allData.Count; i++)
			{
				CardInfo val = allData[i];
				for (int j = 0; j < val.Abilities.Count; j++)
				{
					Ability val2 = val.Abilities[j];
					if (NewSigilVersions.ContainsKey(val2))
					{
						allData[i].abilities[j] = GetCustomAbility(NewSigilVersions[val2], AbilitiesUtil.GetInfo(val2).rulebookName);
					}
				}
			}
			NewSigilVersions.Keys.ToList().ForEach(delegate(Ability x)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				AbilityManager.Remove(x);
			});
		}

		public string GetSigilGuid(Ability ability)
		{
			Dictionary<string, Dictionary<string, object>> dictionary = (Dictionary<string, Dictionary<string, object>>)AccessTools.Field(typeof(ModdedSaveData), "SaveData").GetValue(ModdedSaveManager.SaveData);
			foreach (KeyValuePair<string, object> item in dictionary["cyantist.inscryption.api"])
			{
				List<string> list = item.Key.Split(new char[1] { '_' }).ToList();
				if (list[0] == "Ability" && int.TryParse(((object)(Ability)(ref ability)).ToString(), out var result))
				{
					int num = int.Parse((string)item.Value);
					if (num == result)
					{
						return list[1];
					}
				}
			}
			return null;
		}

		private void AddDevStuff()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			AddDev_Activated();
			CardInfo val = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Squirrel");
			val.abilities = new List<Ability> { Draw_Cost.ability };
			val.baseAttack = 1;
			CardInfo val2 = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Wolf");
			val2.abilities = new List<Ability> { Draw_Mox.ability };
			CardInfo val3 = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Mole");
			val3.abilities = new List<Ability> { Draw_Energy.ability };
			val3.baseAttack = 1;
			CardInfo val4 = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Wolf_Talking");
			val4.abilities = new List<Ability>();
			CardInfo val5 = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Grizzly");
			val5.abilities = new List<Ability>();
			val5.baseAttack = 1;
			CardInfo val6 = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, "Stoat");
			val6.abilities = new List<Ability>();
		}

		public static Texture2D GetTexture(string path, bool Act2 = false)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			string text = (Act2 ? "Act2" : "Act1");
			byte[] array = File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(Directory), "Artwork/", "ATS", text + "/", path + ".png"));
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			((Texture)val).filterMode = (FilterMode)0;
			return val;
		}

		public static Texture2D GetTextureLily(string path, bool Act2 = false)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			string text = (Act2 ? "Act2" : "Act1");
			byte[] array = File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(Directory), "Artwork/", "Lily", text + "/", path + ".png"));
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			((Texture)val).filterMode = (FilterMode)0;
			return val;
		}

		public static Texture2D GetTextureAnthony(string path)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			byte[] array = File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(Directory), "Artwork/", "Anthony", path + ".png"));
			Texture2D val = new Texture2D(2, 2);
			ImageConversion.LoadImage(val, array);
			((Texture)val).filterMode = (FilterMode)0;
			return val;
		}

		public static Ability GetCustomAbility(string GUID, string rulebookname)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return GuidManager.GetEnumValue<Ability>(GUID, rulebookname);
		}

		public static void AimWeaponAnim(GameObject TweenObj, Vector3 target)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Tween.LookAt(TweenObj.transform, target, Vector3.up, 0.075f, 0f, Tween.EaseInOut, (LoopType)0, (Action)null, (Action)null, true);
		}

		private void AddActivactedNanoShield()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Activated Latch Nano Shield", "When activated for a cost of 1 energy / 2 bones will allow the owner to give a creature Nano Shield.", typeof(Bi_Blood), (Texture)(object)GetTextureAnthony("activatedlatch-deathshield"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.activated = true;
			val.opponentUsable = false;
			ActivatedLatchNanoShield.ability = val.ability;
			bool flag = false;
		}

		private void AddActivactedBrittle()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Activated Latch Brittle", "When activated for a cost of 1 energy will allow the owner to give a creature Brittle.", typeof(ActivatedLatchBrittle), (Texture)(object)GetTextureAnthony("activatedlatch-brittle"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.activated = true;
			val.opponentUsable = false;
			ActivatedLatchBrittle.ability = val.ability;
			bool flag = false;
		}

		private void AddActivactedExplodeOnDeath()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Activated Latch Explode On Death", "When activated for a cost of 1 energy will allow the owner to give a creature Explode On Death.", typeof(ActivatedLatchExplodeOnDeath), (Texture)(object)GetTextureAnthony("activatedlatch-explodeondeath"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.activated = true;
			val.opponentUsable = false;
			ActivatedLatchExplodeOnDeath.ability = val.ability;
			bool flag = false;
		}

		private void AddActivactedReach()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Activated Latch Reach", "When activated for a cost of 2 energy will allow the owner to give a creature Reach.", typeof(ActivatedLatchReach), (Texture)(object)GetTextureAnthony("acticatedlatch-Reach"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.activated = true;
			val.opponentUsable = false;
			ActivatedLatchReach.ability = val.ability;
			bool flag = false;
		}

		private void AddIncreasePowerDecreaseHealth()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Old Timer", "At the Start of its owner's turn [creature] will gain +1 attack and will take 1 damage.", typeof(IncreasePowerDecreaseHealth), (Texture)(object)GetTextureAnthony("old-timer"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			IncreasePowerDecreaseHealth.ability = val.ability;
			bool flag = false;
		}

		private void AddDecreasePowerIncreaseHealth()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Docile", "At the Start of its owner's turn [creature] will lose -1 attack and will gain +1 health.", typeof(DecreasePowerIncreaseHealth), (Texture)(object)GetTextureAnthony("docile"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			DecreasePowerIncreaseHealth.ability = val.ability;
			bool flag = false;
		}

		private void AddEatChicken()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "To The Slaughter", "At the end of each turn [creature] will eat a random Chicken gaining the same amount of attack as the eaten chicken's health, and gaining the same amount of health as the eaten chicken's attack.", typeof(EatChickens), (Texture)(object)GetTextureAnthony("eatchicken"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			EatChickens.ability = val.ability;
			bool flag = false;
		}

		private void AddChickenCard()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			List<CardMetaCategory> metaCategories = new List<CardMetaCategory>();
			List<Appearance> list = new List<Appearance>();
			list.Add((Appearance)6);
			List<Ability> abilities = new List<Ability> { JustChicken.ability };
			CardInfo val = ScriptableObject.CreateInstance<CardInfo>();
			((Object)val).name = "Chicken";
			val.displayedName = "Chicken";
			val.baseAttack = 1;
			val.baseHealth = 1;
			val.cost = 0;
			CardExtensions.SetPortrait(val, GetTextureAnthony("YisusChickenPortrait"), (FilterMode?)null);
			val.metaCategories = metaCategories;
			val.appearanceBehaviour = list;
			val.cardComplexity = (CardComplexity)1;
			val.abilities = abilities;
			val.temple = (CardTemple)0;
			CardManager.Add("AP", val);
		}

		private void AddChicken()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Chicken", "[creature] counts as a Chicken.", typeof(JustChicken), (Texture)(object)GetTextureAnthony("chicken"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			JustChicken.ability = val.ability;
			bool flag = false;
		}

		private void AddTransformChickenOpp()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Transform Chicken (Opposing)", "When a creature is played opposing [creature] it will turn into a Chicken. A Chicken is defined as 1 Attack, 1 Health.", typeof(TurnIntoChickenOpp), (Texture)(object)GetTextureAnthony("TransformChick_Sigil"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			TurnIntoChickenOpp.ability = val.ability;
			bool flag = false;
		}

		private void AddTransformChickenLooseCannon()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Transform Chicken (Loose Cannon)", "[creature] will transform a random creature on the board into a Chicken. A Chicken is defined as 1 Attack, 1 Health.", typeof(TurnIntoChickenLooseCannon), (Texture)(object)GetTextureAnthony("TransformChick_Sigil"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			TurnIntoChickenLooseCannon.ability = val.ability;
			bool flag = false;
		}

		private void AddTransformChickenEnemyOnly()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("AnthonyPython.inscryption.AnthonysSigils", "Transform Chicken (Enemy Only)", "[creature] will transform a random creature on the board on the opponent's side into a Chicken. A Chicken is defined as 1 Attack, 1 Health.", typeof(TurnIntoChickenEnemyOnly), (Texture)(object)GetTextureAnthony("TransformChick_Sigil"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureAnthony("placeholder_act2"), (FilterMode?)null);
			val.metaCategories = new List<AbilityMetaCategory> { (AbilityMetaCategory)0 };
			val.canStack = false;
			val.opponentUsable = true;
			TurnIntoChickenEnemyOnly.ability = val.ability;
			bool flag = false;
		}

		public void AddAlternating_Scratch()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Alternating Scratch", "When [creature] attacks it will also attack a space adjacent to the attacked slot, the adjacent slot that it will attack will change between left or right at the end of each opponent's turn.", typeof(Alternating_Scratch), (Texture)(object)GetTexture("alternating_scratch"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("alternating_scratch", Act2: true), (FilterMode?)null);
			val.powerLevel = 4;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Alternating_Scratch.ability = val.ability;
			bool flag = false;
		}

		public void AddArmoured()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Shielded", "When [creature] is dealt damage, the damage dealt is halved, rounded down.", typeof(Armoured), (Texture)(object)GetTexture("shielded"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("shielded", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Armoured.ability = val.ability;
			bool flag = false;
		}

		public void AddChoreography()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Choreography", "On activation [creature] will cycle through: don't move, move left and move right. At the end of the owner's turn [creature] will move in the chosen way.", typeof(Choreography), (Texture)(object)GetTexture("choreo_right"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("choreo_right", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			val.activated = true;
			Choreography.ability = val.ability;
			bool flag = false;
		}

		public void AddDraw_Cost()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Draw Cost", "When [creature] is played, a random card that has the same cost type as [creature] is created in your hand.", typeof(Draw_Cost), (Texture)(object)GetTexture("draw_cost"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("draw_cost", Act2: true), (FilterMode?)null);
			val.powerLevel = 4;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Draw_Cost.ability = val.ability;
			bool flag = false;
		}

		public void AddDraw_Energy()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Draw Energy", "When [creature] is played, a random card costing energy is created in your hand.", typeof(Draw_Energy), (Texture)(object)GetTexture("draw_energy"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("draw_energy", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Draw_Energy.ability = val.ability;
			bool flag = false;
		}

		public void AddDraw_Mox()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Draw Mox", "When [creature] is played, a random card costing mox is created in your hand.", typeof(Draw_Mox), (Texture)(object)GetTexture("draw_mox"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("draw_mox", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Draw_Mox.ability = val.ability;
			bool flag = false;
		}

		public void AddDrunk()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Drunk", "[creature] will strike a random one of the opposing spaces to the left and right of the space across from it.", typeof(Drunk), (Texture)(object)GetTexture("drunk"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("drunk", Act2: true), (FilterMode?)null);
			val.powerLevel = 0;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Drunk.ability = val.ability;
			bool flag = false;
		}

		public void AddFrightened()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Frightened", "When a creature moves into the space opposing [creature], [creature] will move away from that card to a random free adjacent spot, while prioritizing slots without any opposing creatures.", typeof(Frightened), (Texture)(object)GetTexture("frightened"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("frightened", Act2: true), (FilterMode?)null);
			val.powerLevel = -1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Frightened.ability = val.ability;
			bool flag = false;
		}

		public void AddHermit()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Hermit", "[creature] may be placed on any terrain card. If it is their sigils and stats will be combined, and a name combination will be created.", typeof(Hermit), (Texture)(object)GetTexture("hermit"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("hermit", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Hermit.ability = val.ability;
			bool flag = false;
		}

		public void AddHoming()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Homing", "If the opposing slot is empty, and there is a creature in a neighbouring lane, [creature] will attack that creature instead of attacking the opposing slot.", typeof(Homing), (Texture)(object)GetTexture("homing"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("homing", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Homing.ability = val.ability;
			bool flag = false;
		}

		public void AddHoodini()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Hoodini", "When [creature] is played, it will swap places with the opposing creature.", typeof(Hoodini), (Texture)(object)GetTexture("hoodini"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("hoodini", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Hoodini.ability = val.ability;
			bool flag = false;
		}

		public void AddHyped()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Hyped", "[creature] will attack at the start of the owner's turn in addition to during normal combat.", typeof(Hyped), (Texture)(object)GetTexture("hyped"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("hyped", Act2: true), (FilterMode?)null);
			val.powerLevel = 0;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Hyped.ability = val.ability;
			bool flag = false;
		}

		public void AddInaccurate()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Inaccurate", "[creature] will strike a random one of the opposing spaces to the left and right of the spaces across from it as well as the space in front of it.", typeof(Inaccurate), (Texture)(object)GetTexture("inaccurate"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("inaccurate", Act2: true), (FilterMode?)null);
			val.powerLevel = 0;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Inaccurate.ability = val.ability;
			bool flag = false;
		}

		public void AddLullaby()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Lullaby", "When [creature] dies, all opposing creatures gain the asleep sigil.", typeof(Lullaby), (Texture)(object)GetTexture("lullaby"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("lullaby", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Lullaby.ability = val.ability;
			bool flag = false;
		}

		public void AddMedical_Aid()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Medical Aid", "At the end of the opponent's turn, choose a hurt creature on the owner's side to heal for 1.", typeof(Medical_Aid), (Texture)(object)GetTexture("medical_aid"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("medical_aid", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Medical_Aid.ability = val.ability;
			bool flag = false;
		}

		public void AddMount()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Mount", "Cards may be played on top of [creature]. If they are their sigils and stats will be combined, and a name combination will be created.", typeof(Mount), (Texture)(object)GetTexture("mount"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("mount", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Mount.ability = val.ability;
			bool flag = false;
		}

		public void AddNurse()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Nurse", "At the end of the opponent's turn, [creature] will heal any adjacent friendly cards.", typeof(Nurse), (Texture)(object)GetTexture("nurse"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("nurse", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Nurse.ability = val.ability;
			bool flag = false;
		}

		public void AddParasite()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Parasite", "[creature] may be placed on top of any card. If it is their sigils and stats will be combined, and a name combination will be created.", typeof(Parasite), (Texture)(object)GetTexture("parasite"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("parasite", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Parasite.ability = val.ability;
			bool flag = false;
		}

		public void AddResourceful()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Resourceful", "When [creature] is sacrificed, instead of dying, it loses a random sigil. Resourceful will only remove itself when there are no other sigils on the card.", typeof(Resourceful), (Texture)(object)GetTexture("resourceful"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("resourceful", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Resourceful.ability = val.ability;
			bool flag = false;
		}

		public void AddChangePortraitWhenMerged()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			FullSpecialTriggeredAbility val = SpecialTriggeredAbilityManager.Add("ATS", "ChangePortraitWhenMerged", typeof(ChangePortraitWhenMerged));
			ChangePortraitWhenMerged.ability = val.Id;
		}

		public void AddSympathetic()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Sympathetic", "[creature] will only attack if the opposing creature has more or equal health to it.", typeof(Sympathetic), (Texture)(object)GetTexture("sympathetic"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("sympathetic", Act2: true), (FilterMode?)null);
			val.powerLevel = -2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Sympathetic.ability = val.ability;
			bool flag = false;
		}

		public void AddTerrified()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Terrified", "When a creature moves into the space opposing [creature], [creature] will move away from that card to a random free adjacent spot while pushing any creatures in it's way, while prioritizing slots without any opposing creatures.", typeof(Terrified), (Texture)(object)GetTexture("terrified"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("terrified", Act2: true), (FilterMode?)null);
			val.powerLevel = 0;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Terrified.ability = val.ability;
			bool flag = false;
		}

		public void AddUnderdog()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("ATS", "Underdog", "[creature] can only be played when you are losing.", typeof(Underdog), (Texture)(object)GetTexture("underdog"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTexture("underdog", Act2: true), (FilterMode?)null);
			val.powerLevel = -1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Underdog.ability = val.ability;
			bool flag = false;
		}

		public void AddFight_Activated()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Charge", "Pay 3 bones to choose an enemy creature that [creature] will strike.", typeof(Fight_Activated), (Texture)(object)GetTextureLily("charge"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 5;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			val.activated = true;
			Fight_Activated.ability = val.ability;
			bool flag = false;
		}

		public void AddAsleep()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Asleep", "[creature] has 0 attack for as long as it has this sigil, at the start of the player's turn this sigil will be removed from [creature].", typeof(Asleep), (Texture)(object)GetTextureLily("asleep"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("asleep", Act2: true), (FilterMode?)null);
			val.powerLevel = -1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Asleep.ability = val.ability;
			bool flag = false;
			bool flag2 = false;
		}

		public void AddDouble_Slash()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Double scratch", "When [creature] attacks it attacks twice and the space right and left of the attacked slot.", typeof(Double_Slash), (Texture)(object)GetTextureLily("double_scratch"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("double_scratch", Act2: true), (FilterMode?)null);
			val.powerLevel = 6;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Double_Slash.ability = val.ability;
			bool flag = false;
		}

		public void AddLeft_Slash()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Left scratch", "When [creature] attacks it will also attack the space on the left of the attacked slot.", typeof(Left_Slash), (Texture)(object)GetTextureLily("left_scratch"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("left_scratch", Act2: true), (FilterMode?)null);
			val.powerLevel = 4;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Left_Slash.ability = val.ability;
			bool flag = false;
		}

		public void AddRight_Slash()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Right scratch", "When [creature] attacks it will also attack the space on the right of the attacked slot.", typeof(Right_Slash), (Texture)(object)GetTextureLily("right_scratch"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("right_scratch", Act2: true), (FilterMode?)null);
			val.powerLevel = 4;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Right_Slash.ability = val.ability;
			bool flag = false;
		}

		public void AddBait()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bait", "When an opposing creature is played and there is no card opposite of [creature], the opposing creature will move to that spot.", typeof(Bait), (Texture)(object)GetTextureLily("bait"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("bait", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Bait.ability = val.ability;
			bool flag = false;
		}

		public void AddBi_Blood()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Noble Sacrifice", "[creature] is counted as 2 blood rather than 1 blood when sacrificed.", typeof(Bi_Blood), (Texture)(object)GetTextureLily("bi_blood"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("bi_blood", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Bi_Blood.ability = val.ability;
			bool flag = false;
		}

		public void AddQuadra_Blood()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Superior Sacrifice", "[creature] is counted as 4 blood rather than 1 blood when sacrificed.", typeof(Quadra_Blood), (Texture)(object)GetTextureLily("quadra_blood"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("quadra_blood", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Quadra_Blood.ability = val.ability;
			bool flag = false;
		}

		public void AddBlood_Shifter()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Blood shifter", "When [creature] kills another card, it will turn into that card.", typeof(Blood_Shifter), (Texture)(object)GetTextureLily("blood_shifter"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("blood_shifter", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = true;
			Blood_Shifter.ability = val.ability;
			bool flag = false;
		}

		public void AddFiveDeathBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone lord 5", "When [creature] dies, 5 bones are rewarded instead of 1.", typeof(FiveDeathBones), (Texture)(object)GetTextureLily("fivedeathbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("fivedeathbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			FiveDeathBones.ability = val.ability;
			bool flag = false;
		}

		public void AddOneSummonBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone hoarder 1", "When [creature] is played, 1 bone is rewarded.", typeof(OneSummonBones), (Texture)(object)GetTextureLily("onesummonbone"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("onesummonbone", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			OneSummonBones.ability = val.ability;
			bool flag = false;
		}

		public void AddSixDeathBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone lord 6", "When [creature] dies, 6 bones are rewarded instead of 1.", typeof(SixDeathBones), (Texture)(object)GetTextureLily("sixdeathbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("sixdeathbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			SixDeathBones.ability = val.ability;
			bool flag = false;
		}

		public void AddThreeDeathBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone prince 3", "When [creature] dies, 3 bones are rewarded instead of 1.", typeof(ThreeDeathBones), (Texture)(object)GetTextureLily("threedeathbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("threedeathbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			ThreeDeathBones.ability = val.ability;
			bool flag = false;
		}

		public void AddThreeSummonBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone hoarder 3", "When [creature] is played, 3 bones are rewarded.", typeof(ThreeSummonBones), (Texture)(object)GetTextureLily("threesummonbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("threesummonbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			ThreeSummonBones.ability = val.ability;
			bool flag = false;
		}

		public void AddTwoDeathBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone prince 2", "When [creature] dies, 2 bones are rewarded instead of 1.", typeof(TwoDeathBones), (Texture)(object)GetTextureLily("twodeathbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("twodeathbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			TwoDeathBones.ability = val.ability;
			bool flag = false;
		}

		public void AddTwoSummonBones()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bone hoarder 2", "When [creature] is played, 2 bones are rewarded.", typeof(TwoSummonBones), (Texture)(object)GetTextureLily("twosummonbones"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("twosummonbones", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			TwoSummonBones.ability = val.ability;
			bool flag = false;
		}

		public void AddHost()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Host", "[creature] is the host of other creatures. It will give you such creature when struck.", typeof(Host), (Texture)(object)GetTextureLily("host"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("host", Act2: true), (FilterMode?)null);
			val.powerLevel = 5;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Host.ability = val.ability;
			bool flag = false;
		}

		public void AddLauncher()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Launcher", "At the end of its owner's turn, [creature] will create another creature on a random empty space on the owner's side of the table.", typeof(Launcher), (Texture)(object)GetTextureLily("launcher"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("launcher", Act2: true), (FilterMode?)null);
			val.powerLevel = 5;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Launcher.ability = val.ability;
			bool flag = false;
		}

		public void AddShape_Shifter()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Shapeshifter", "[creature] is ever changing. It will change its form once it's struck.", typeof(Shape_Shifter), (Texture)(object)GetTextureLily("shape_shifter"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("shape_shifter", Act2: true), (FilterMode?)null);
			val.powerLevel = 5;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Shape_Shifter.ability = val.ability;
			bool flag = false;
		}

		public void AddSpawner()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Spawner", "At the end of its owner's turn, [creature] will move in the direction inscribed on the sigil and will create another creature in its old space.", typeof(Spawner), (Texture)(object)GetTextureLily("spawner"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("spawner", Act2: true), (FilterMode?)null);
			val.powerLevel = 5;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Spawner.ability = val.ability;
			bool flag = false;
		}

		public void AddDev_Activated()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Wharrgarbl", "Wharrgarbl.", typeof(Dev_Activated), (Texture)(object)GetTextureLily("placeholder"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 69420;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			val.activated = true;
			Dev_Activated.ability = val.ability;
		}

		public void AddDraw_Side_Deck_OnSummon()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Support call", "When [creature] is played, a card from your sidedeck is created in your hand.", typeof(Draw_Side_Deck_OnSummon), (Texture)(object)GetTextureLily("support_call"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			Draw_Side_Deck_OnSummon.ability = val.ability;
			bool flag = false;
		}

		public void AddFearful()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Fearful", "When [creature] is struck without it resulting in death, it will be returned to its owner's hand.", typeof(Fearful), (Texture)(object)GetTextureLily("fearful"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("fearful", Act2: true), (FilterMode?)null);
			val.powerLevel = -2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Fearful.ability = val.ability;
			bool flag = false;
		}

		public void AddHydra()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Exhaustion", "The attack of [creature] will be decreased by the same amount as its lost health.", typeof(Hydra), (Texture)(object)GetTextureLily("exhaustion"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("exhaustion", Act2: true), (FilterMode?)null);
			val.powerLevel = -2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Hydra.ability = val.ability;
			bool flag = false;
		}

		public void AddImbuing()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Imbuing", "[creature] will get specific buffs depending on which tribe is most promenent in the sacrifices that were used to summon it.", typeof(Imbuing), (Texture)(object)GetTextureLily("imbuing"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Imbuing.ability = val.ability;
			bool flag = false;
		}

		public void AddInstakill()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Instant", "[creature] will perish immediately after its played.", typeof(Instakill), (Texture)(object)GetTextureLily("instant"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("instant", Act2: true), (FilterMode?)null);
			val.powerLevel = -3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Instakill.ability = val.ability;
			bool flag = false;
		}

		public void AddRushing_March()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Rushing march", "At the end of its owner's turn, [creature] will move in the direction inscribed on the sigil, however if it hits a card whilst moving, [creature] will stop and the card it hit will perish.", typeof(Rushing_March), (Texture)(object)GetTextureLily("rushing_march"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("rushing_march", Act2: true), (FilterMode?)null);
			val.powerLevel = -2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Rushing_March.ability = val.ability;
			bool flag = false;
		}

		public void AddWarper()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Warper", "At the end of its owner's turn, [creature] will move to the right, jumping over any creatures in its path, if it encounters the edge of the board, it will loop over to the other side.", typeof(Warper), (Texture)(object)GetTextureLily("warper"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("warper", Act2: true), (FilterMode?)null);
			val.powerLevel = 1;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Warper.ability = val.ability;
			bool flag = false;
		}

		public void AddWild_Hunger()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Wild hunger", "At the end of its owner's turn, [creature] will move in the direction inscribed on the sigil, however if it hits a card whilst moving, [creature] will stop, the card it hit will perish and [creature] will gain 1+/1+.", typeof(Wild_Hunger), (Texture)(object)GetTextureLily("wild_hunger"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("wild_hunger", Act2: true), (FilterMode?)null);
			val.powerLevel = 4;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Wild_Hunger.ability = val.ability;
			bool flag = false;
		}

		public void AddAll_Seeing()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "All seeing", "While [creature] is on the board, all talking cards on your side of the board get +2 health.", typeof(All_Seeing), (Texture)(object)GetTextureLily("all_seeing"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = false;
			All_Seeing.ability = val.ability;
			bool flag = false;
		}

		public void AddBond()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Bond", "Any creatures adjacent to [creature] will gain either +1 attack or +1 health, depending on which stat it is closest to.", typeof(Bond), (Texture)(object)GetTextureLily("Bond"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("bond", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Bond.ability = val.ability;
			bool flag = false;
		}

		public void AddLinguist()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Linguist", "While [creature] is on the board, all talking cards on your side of the board get +1 attack.", typeof(Linguist), (Texture)(object)GetTextureLily("linguist"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Linguist.ability = val.ability;
			bool flag = false;
		}

		public void AddPuppets_Gift()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Puppets gift", "As long as [creature] is on the board any cards with brittle won't die because of brittle.", typeof(Puppets_Gift), (Texture)(object)GetTextureLily("puppets_gift"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("puppets_gift", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Puppets_Gift.ability = val.ability;
			bool flag = false;
		}

		public void AddTribe_Attack()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Tribe Attack", "While [creature] is on the board, all other cards on your side of the board of the same tribe will gain +1 attack.", typeof(Tribe_Attack), (Texture)(object)GetTextureLily("tribe_attack"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 3;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Tribe_Attack.ability = val.ability;
			bool flag = false;
		}

		public void AddTribe_Health()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Tribe Health", "While [creature] is on the board, all other cards on your side of the board of the same tribe will gain +1 health.", typeof(Tribe_Health), (Texture)(object)GetTextureLily("tribe_health"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("placeholder", Act2: true), (FilterMode?)null);
			val.powerLevel = 2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = true;
			val.opponentUsable = true;
			Tribe_Health.ability = val.ability;
			bool flag = false;
		}

		public void AddPicky()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Picky", "[creature] cannnot be summoned by using any free cards as sacrifice.", typeof(Picky), (Texture)(object)GetTextureLily("picky"));
			AbilityExtensions.SetPixelAbilityIcon(val, GetTextureLily("picky", Act2: true), (FilterMode?)null);
			val.powerLevel = -2;
			val.metaCategories = new List<AbilityMetaCategory>
			{
				(AbilityMetaCategory)0,
				(AbilityMetaCategory)1
			};
			val.canStack = false;
			val.opponentUsable = false;
			Picky.ability = val.ability;
			bool flag = false;
		}

		public void AddShort()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			AbilityInfo val = AbilityManager.New("org.memez4life.inscryption.customsigils", "Short", "[creature] will not be blocked by an opposing creature bearing the airborn sigil.", typeof(Short), (Texture)(object)GetTextureLily("short"));
			AbilityExtensions.SetPixelAbilityIcon(val, G