using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using HarmonyLib;
using LBoL.Base;
using LBoL.Base.Extensions;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Helpers;
using LBoL.Core.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.Stations;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Adventures.Stage2;
using LBoL.EntityLib.Cards.Adventure;
using LBoL.EntityLib.Cards.Character.Marisa;
using LBoL.EntityLib.Cards.Character.Sakuya;
using LBoL.EntityLib.Cards.Enemy;
using LBoL.EntityLib.Cards.Neutral.Black;
using LBoL.EntityLib.Cards.Neutral.NoColor;
using LBoL.EntityLib.EnemyUnits.Normal.Yinyangyus;
using LBoL.EntityLib.Exhibits;
using LBoL.Presentation;
using LBoL.Presentation.UI.Panels;
using LBoL.Presentation.UI.Widgets;
using LBoLEntitySideloader;
using LBoLEntitySideloader.Attributes;
using LBoLEntitySideloader.Entities;
using LBoLEntitySideloader.PersistentValues;
using LBoLEntitySideloader.PersistentValues.TypeConverters;
using LBoLEntitySideloader.ReflectionHelpers;
using LBoLEntitySideloader.Resource;
using LBoLEntitySideloader.UIAdditions.CardUIAdds;
using LBoLEntitySideloader.Utils;
using UnityEngine;
using VariantsC.Marisa.C;
using VariantsC.Reimu.C;
using VariantsC.Rng;
using VariantsC.Sakuya.C;
using VariantsC.Shared;
using YamlDotNet.Serialization;

[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.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("VariantsC")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("VariantsC")]
[assembly: AssemblyTitle("VariantsC")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace VariantsC
{
	public static class CustomLoadouts
	{
		public static void AddLoadouts()
		{
			List<string> second = new List<string> { "Shoot", "Shoot", "Boundary", "Boundary" };
			PlayerUnitTemplate.AddLoadout("Reimu", "JabReimuCUlt", "ChocolateCoinEx", new List<string> { "ReimuAttackR", "ReimuAttackW", "ReimuBlockR", "ReimuBlockW", "BalancedBasicCard", "RollingPebbleCard" }.Concat(second).ToList(), 2, (Assembly)null);
			PlayerUnitTemplate.AddLoadout("Sakuya", "BatFormUlt", "BloodyRipperEx", new List<string> { "SakuyaAttackU", "SakuyaAttackW", "SakuyaBlockU", "SakuyaBlockW", "ConsequenceOfHickeysCard", "ChaoticBloodMagicCard", "Shoot", "Shoot", "Shoot", "Boundary" }.ToList(), 3, (Assembly)null);
			PlayerUnitTemplate.AddLoadout("Marisa", "SpringCleaningUlt", "PachyBagEx", new List<string> { "EverHoardingCard", "Potion", "BasicTreasurePack", "BasicAttacksPack", "BasicDefencePack", "BasicMiseryPack" }.ToList(), 2, (Assembly)null);
		}
	}
	[BepInPlugin("neo.lbol.gameplay.VariantsC", "Variants C", "0.5.5000")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static TemplateSequenceTable sequenceTable = new TemplateSequenceTable(0);

		internal static IResourceSource embeddedSource = (IResourceSource)new EmbeddedSource(Assembly.GetExecutingAssembly());

		internal static DirectorySource directorySource = new DirectorySource("neo.lbol.gameplay.VariantsC", "");

		internal static ConfigEntry<bool> poolNewCards;

		internal static ConfigEntry<bool> poolNewExhibits;

		internal static BatchLocalization CardBatchLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(CardTemplate), "Card", (Locale)0, false);

		internal static BatchLocalization StatusEffectBatchLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(StatusEffectTemplate), "StatusEffect", (Locale)0, false);

		internal static BatchLocalization ExhibitBatchLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(ExhibitTemplate), "Exhibit", (Locale)0, false);

		internal static BatchLocalization UltimateSkillBatchLoc = new BatchLocalization((IResourceSource)(object)directorySource, typeof(UltimateSkillTemplate), "UltimateSkill", (Locale)0, false);

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			poolNewCards = ((BaseUnityPlugin)this).Config.Bind<bool>("Pools", "poolNewCardsWhenExhibit", false, "Pool new starting cards of a loadout when not in a possession of the corresponding loadout exhibit. For example, when set to false, Blood Magic and Consequence of Hickeys cards won't be rewarded or generated unless player has Bloody Ripper exhibit.");
			poolNewExhibits = ((BaseUnityPlugin)this).Config.Bind<bool>("Pools", "poolNewExhibits", false, "Makes C variant exhibits discoverable after defeating their owner.");
			((CustomGameRunSaveData)new SaveContainer()).RegisterSelf("neo.lbol.gameplay.VariantsC");
			EntityManager.RegisterSelf();
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
			CustomLoadouts.AddLoadouts();
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public class Config
	{
		[HarmonyPatch]
		private class Gr_cctor_Patch
		{
			private static IEnumerable<MethodBase> TargetMethods()
			{
				yield return AccessTools.Constructor(typeof(GameRunController), new Type[1] { typeof(GameRunStartupParameters) }, false);
			}

			private static void Postfix(GameRunController __instance)
			{
				if (!BepinexPlugin.poolNewExhibits.Value)
				{
					__instance.ShiningExhibitPool.RemoveAll((Type t) => cExhibits.Contains(t));
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private class EnumerateRollableCardTypes_Patch
		{
			private static int CheckConfig(CardType cardType, CardConfig config)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				if ((int)cardType == 8)
				{
					return 0;
				}
				GameRunController currentGameRun = Singleton<GameMaster>.Instance.CurrentGameRun;
				if (currentGameRun != null && !BepinexPlugin.poolNewCards.Value && newCards.SelectMany((string[] l) => l).Contains(config.Id))
				{
					return (from ex in currentGameRun.Player.Exhibits
						select Array.IndexOf(cExhibits, ((object)ex).GetType()) into i
						where i >= 0
						select i).SelectMany((int i) => newCards[i]).Contains(config.Id) ? 1 : 0;
				}
				return 1;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
			{
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(CardConfig), "Type"))) }).MatchEndForward((CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(OpCodes.Ldloc_S) }).Advance(1)
					.RemoveInstruction()
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldloc_2, (object)null)
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(EnumerateRollableCardTypes_Patch), "CheckConfig", (Type[])null, (Type[])null))
					})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldc_I4_0, (object)null)
					})
					.InstructionEnumeration();
			}
		}

		public static readonly Type[] cExhibits = new Type[3]
		{
			typeof(ChocolateCoinEx),
			typeof(BloodyRipperEx),
			typeof(PachyBagEx)
		};

		public static readonly string[][] newCards = new string[3][]
		{
			new string[1] { "RollingPebbleCard" },
			new string[2] { "ConsequenceOfHickeysCard", "ChaoticBloodMagicCard" },
			new string[1] { "EverHoardingCard" }
		};
	}
	public static class Helpers
	{
		public static int ToInt(this bool value)
		{
			return value ? 1 : 0;
		}
	}
	public static class PInfo
	{
		public const string GUID = "neo.lbol.gameplay.VariantsC";

		public const string Name = "Variants C";

		public const string version = "0.5.5000";

		public static readonly Harmony harmony = new Harmony("neo.lbol.gameplay.VariantsC");
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace VariantsC.Shared
{
	public sealed class BalancedBasicCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BalancedBasicCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)1;
			List<ManaColor> list = new List<ManaColor>();
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 2;
			return new CardConfig(0, "", 10, true, array, "ShootC", "ShootC1", 0, false, false, true, false, true, (Rarity)0, (CardType)1, val, (IReadOnlyList<ManaColor>)list, false, val2, (ManaGroup?)null, (int?)null, (int?)4, (int?)7, (int?)4, (int?)7, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)2, (Keyword)2, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (string)null, "", "", false, "白Shiro@", (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(BalancedBasicCardDef))]
	public sealed class BalancedBasicCard : Card
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return ((Card)this).DefenseAction(true);
			yield return ((Card)this).AttackAction(selector, (GunPair)null);
		}
	}
	public static class CardColors
	{
		public static readonly string common = "#a0a1a0";

		public static readonly string uncommon = "#3277d1";

		public static readonly string rare = "#d6cd28";

		public static readonly string basicAndCommon = "#898e89";

		public static readonly string misfortune = "#8a3baf";

		public static readonly string status = "#b25eee";

		public static string ColorName(Card card, string defaultColor = "#000000")
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected I4, but got Unknown
			string text = ((GameEntity)card).Name + (card.IsUpgraded ? " +" : "");
			if (card.IsBasic && (int)card.Config.Rarity == 0)
			{
				return text.WrapHex(basicAndCommon);
			}
			CardType cardType = card.CardType;
			CardType val = cardType;
			if ((int)val != 7)
			{
				if ((int)val == 8)
				{
					return text.WrapHex(misfortune);
				}
				Rarity rarity = card.Config.Rarity;
				Rarity val2 = rarity;
				switch ((int)val2)
				{
				case 0:
					return text.WrapHex(common);
				case 1:
					return text.WrapHex(uncommon);
				case 2:
				case 3:
				case 4:
					return text.WrapHex(rare);
				default:
					return text.WrapHex(defaultColor);
				}
			}
			return text.WrapHex(status);
		}

		public static string WrapHex(this string text, string hex)
		{
			return "<color=" + hex + ">" + text + "</color>";
		}
	}
	public class ProcessDeckCardsAction : SimpleAction
	{
		[HarmonyPatch(typeof(ActionResolver), "InternalResolve")]
		private class CaputreActionResolverDepth
		{
			public static int capDepth;

			private static void Prefix(BattleAction action, int depth)
			{
				if (((object)action).GetType() == typeof(ProcessDeckCardsAction))
				{
					capDepth = depth;
				}
			}
		}

		private Card[] cards;

		private Action<IEnumerable<Card>> proccessAction;

		private readonly string actionTitle;

		public int batchSize = 5;

		public float finalDelay = 0.5f;

		public float batchDelay = 0.4f;

		private int resolutionDepth;

		public ProcessDeckCardsAction(Card[] cards, Action<IEnumerable<Card>> proccessAction, string actionTitle)
		{
			this.cards = cards;
			this.proccessAction = proccessAction;
			this.actionTitle = actionTitle;
		}

		public override void ResolvePhase()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			((BattleAction)this).React(Reactor.op_Implicit((BattleAction)new WaitForCoroutineAction(ProcessManyCards())), (GameEntity)null, (ActionCause?)null);
			CaputreActionResolverDepth.capDepth = 0;
		}

		public override string ExportDebugDetails()
		{
			StringBuilder pad = new StringBuilder("     ");
			resolutionDepth = CaputreActionResolverDepth.capDepth + 2;
			for (int i = 0; i < resolutionDepth; i++)
			{
				pad.Append("         ");
			}
			return actionTitle + ": \n" + string.Join("\n", cards.Select((Card c) => string.Concat(new string[2]
			{
				pad.ToString(),
				CardColors.ColorName(c)
			})));
		}

		private IEnumerator ProcessManyCards()
		{
			for (int i = 0; i < cards.Length; i += batchSize)
			{
				int upper = Math.Min(cards.Length, i + batchSize);
				Card[] display = cards[i..upper];
				proccessAction(display);
				if (upper < cards.Length)
				{
					yield return (object)new WaitForSecondsRealtime(batchDelay + 0.2f * (float)batchSize);
				}
			}
			yield return (object)new WaitForSecondsRealtime(finalDelay);
		}
	}
	public class StackDrawToDiscard : EventBattleAction<GameEventArgs>
	{
		private static class Viewer
		{
			public static IEnumerator ViewMove(StackDrawToDiscard action, CardUi cardUi)
			{
				if (cardUi.DrawCount > 0)
				{
					AudioManager.PlayUi("CardReshuffle", false);
					int count = Math.Min(cardUi.DrawCount, 10);
					for (int i = 0; i < count; i++)
					{
						AudioManager.PlayUi("CardFly", false);
						Transform parent = Object.Instantiate<Transform>(cardUi.cardFlyHelperPrefab, cardUi.cardEffectLayer);
						parent.localPosition = ((Component)cardUi.discardButton).transform.localPosition;
						CardFlyBrief clone = Object.Instantiate<CardFlyBrief>(cardUi.cardFlyBrief, parent);
						Transform transform = ((Component)clone).transform;
						TweenSettingsExtensions.OnComplete<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOLocalMove(parent, ((Component)cardUi.discardButton).transform.localPosition, 0.5f, false), (Ease)2), (TweenCallback)delegate
						{
							clone.CloseCard();
							Object.Destroy((Object)(object)((Component)parent).gameObject, 0.5f);
						});
						int num = Random.Range(100, 300);
						TweenSettingsExtensions.SetLoops<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetRelative<TweenerCore<Vector3, Vector3, VectorOptions>>(TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOLocalMoveY(transform, (float)num, 0.25f, false), (Ease)3), true), 2, (LoopType)1);
						yield return (object)new WaitForSecondsRealtime(0.05f);
					}
					yield return (object)new WaitForSecondsRealtime(0.3f);
					cardUi.DrawCount = cardUi.Battle.DrawZone.Count;
					cardUi.DiscardCount = cardUi.Battle.DiscardZone.Count;
					cardUi.ExileCount = cardUi.Battle.ExileZone.Count;
				}
				cardUi.RefreshAll();
			}
		}

		[HarmonyPatch(typeof(CardUi), "EnterBattle")]
		private class CardUiEnterBattle_Patch
		{
			private static void Postfix(CardUi __instance)
			{
				BattleActionViewer<StackDrawToDiscard> val = CardUiExtensions.BAV_DelegateWrap<StackDrawToDiscard>((Func<StackDrawToDiscard, CardUi, IEnumerator>)Viewer.ViewMove, __instance);
				__instance.Battle.ActionViewer.Register<StackDrawToDiscard>(val, (Predicate<StackDrawToDiscard>)null);
			}
		}

		[HarmonyPatch(typeof(CardUi), "LeaveBattle")]
		private class CardUiLeaveBattle_Patch
		{
			private static void Prefix(CardUi __instance)
			{
				BattleActionViewer<StackDrawToDiscard> val = CardUiExtensions.BAV_DelegateWrap<StackDrawToDiscard>((Func<StackDrawToDiscard, CardUi, IEnumerator>)Viewer.ViewMove, __instance);
				__instance.Battle.ActionViewer.Unregister<StackDrawToDiscard>(val);
			}
		}

		public override bool IsCanceled => false;

		public StackDrawToDiscard()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			base.Args = new GameEventArgs();
		}

		public void ResolvePhase()
		{
			foreach (Card item in ((BattleAction)this).Battle._drawZone)
			{
				item.Zone = (CardZone)3;
			}
			((BattleAction)this).Battle._discardZone.AddRange(((BattleAction)this).Battle._drawZone);
			((BattleAction)this).Battle._drawZone.Clear();
		}

		public override IEnumerable<Phase> GetPhases()
		{
			yield return ((BattleAction)this).CreatePhase("Main", (Action)ResolvePhase, false);
			yield return ((BattleAction)this).CreatePhase("Visual", (Action)delegate
			{
			}, true);
		}
	}
}
namespace VariantsC.Sakuya.C
{
	public sealed class BatFormUltDef : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BatFormUlt");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.UltimateSkillBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourceLoader.LoadSprite("BatFormUlt.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}

		public override UltimateSkillConfig MakeConfig()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 100, 100, 2, (UsRepeatableType)1, 0, 2, 2, (Keyword)0, (IReadOnlyList<string>)new List<string> { "BloodDrainSe" }, (IReadOnlyList<string>)new List<string> { "Knife" });
		}
	}
	[EntityLogic(typeof(BatFormUltDef))]
	public sealed class BatFormUlt : UltimateSkill
	{
		public BatFormUlt()
		{
			((UltimateSkill)this).TargetType = (TargetType)4;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Owner, ((GameEntity)this).Id);
			yield return (BattleAction)(object)PerformAction.Effect((Unit)(object)((UltimateSkill)this).Owner, "MoonR", 0f, "Wolf", 0f, (EffectBehavior)0, 0f);
			yield return (BattleAction)(object)new ApplyStatusEffectAction<BloodDrainSe>((Unit)(object)((UltimateSkill)this).Owner, (int?)((UltimateSkill)this).Value1, (int?)1, (int?)null, (int?)null, 0f, true);
			yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<Knife>(((UltimateSkill)this).Value2, false), (AddCardsType)0);
		}
	}
	public sealed class BloodDrainSeDef : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BloodDrainSe");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.StatusEffectBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourcesHelper.TryGetSprite<StatusEffect>("Vampire");
		}

		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = ObjectExtensions.Copy<StatusEffectConfig>(StatusEffectConfig.FromId("Vampire"));
			val.HasLevel = true;
			val.LevelStackType = (StackType)0;
			val.HasDuration = true;
			val.DurationStackType = (StackType)3;
			val.Keywords = (Keyword)0;
			val.DurationDecreaseTiming = (DurationDecreaseTiming)3;
			return val;
		}
	}
	[EntityLogic(typeof(BloodDrainSeDef))]
	public sealed class BloodDrainSe : StatusEffect
	{
		private Stack<GameEntity> dmgSources = new Stack<GameEntity>();

		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).ReactOwnerEvent<StatisticalDamageEventArgs>(((StatusEffect)this).Owner.StatisticalTotalDamageDealt, (EventSequencedReactor<StatisticalDamageEventArgs>)OnStatisticalDamageDealt);
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(((StatusEffect)this).Owner.DamageDealt, (GameEventHandler<DamageEventArgs>)OnDamageDealt);
		}

		private bool CouldActivate(DamageInfo damageInfo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			return (int)((DamageInfo)(ref damageInfo)).DamageType == 2 && ((DamageInfo)(ref damageInfo)).Amount > 0f;
		}

		private void OnDamageDealt(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((GameEventArgs)args).Cause != 20 && CouldActivate(args.DamageInfo) && dmgSources.Count < ((StatusEffect)this).Level && !dmgSources.Contains(((GameEventArgs)args).ActionSource))
			{
				dmgSources.Push(((GameEventArgs)args).ActionSource);
			}
		}

		private IEnumerable<BattleAction> OnStatisticalDamageDealt(StatisticalDamageEventArgs args)
		{
			bool activated = false;
			if (dmgSources.Count <= 0 || dmgSources.Peek() != ((GameEventArgs)args).ActionSource)
			{
				yield break;
			}
			foreach (KeyValuePair<Unit, IReadOnlyList<DamageEventArgs>> unitDmgs in args.ArgsTable)
			{
				int totalHeal = 0;
				unitDmgs.Deconstruct(out var unit, out var damageEvents);
				foreach (DamageEventArgs dmg in damageEvents)
				{
					if (CouldActivate(dmg.DamageInfo))
					{
						activated = true;
						int num = totalHeal;
						DamageInfo damageInfo = dmg.DamageInfo;
						totalHeal = num + MathExtensions.ToInt(((DamageInfo)(ref damageInfo)).Damage);
					}
				}
				if (totalHeal > 0)
				{
					<>n__0();
					yield return (BattleAction)new HealAction(unit, ((StatusEffect)this).Owner, totalHeal, (HealType)1, 0f);
				}
				unit = null;
				damageEvents = null;
			}
			if (activated)
			{
				int level = ((StatusEffect)this).Level;
				((StatusEffect)this).Level = level - 1;
				if (((StatusEffect)this).Level <= 0)
				{
					yield return (BattleAction)new RemoveStatusEffectAction((StatusEffect)(object)this, true, 0.1f);
				}
			}
			dmgSources.Pop();
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private void <>n__0()
		{
			((StatusEffect)this).NotifyActivating();
		}
	}
	public sealed class BloodyRipperExDef : ExhibitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BloodyRipperEx");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.ExhibitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ExhibitSprites LoadSprite()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			return new ExhibitSprites(ResourceLoader.LoadSprite("BloodyRipperEx.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null));
		}

		public override ExhibitConfig MakeConfig()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			return new ExhibitConfig(0, "", 25, false, false, false, false, (AppearanceType)0, "Sakuya", (ExhibitLosableType)1, (Rarity)3, (int?)13, (int?)3, (int?)null, (ManaGroup?)null, (ManaColor?)null, (ManaColor?)(ManaColor)4, 1, true, (int?)null, (Keyword)0, (IReadOnlyList<string>)new List<string> { "BloodDrainSe" }, (IReadOnlyList<string>)new List<string> { "Knife" });
		}
	}
	[EntityLogic(typeof(BloodyRipperExDef))]
	public sealed class BloodyRipperEx : ShiningExhibit
	{
		private int TrackCounter
		{
			get
			{
				return ((Exhibit)this).Counter;
			}
			set
			{
				((Exhibit)this).Counter = Math.Max(0, value);
				BloodyRipperSe bloodyRipperSe = default(BloodyRipperSe);
				if (((Unit)((Exhibit)this).Owner).TryGetStatusEffect<BloodyRipperSe>(ref bloodyRipperSe))
				{
					((StatusEffect)bloodyRipperSe).Count = ((Exhibit)this).Counter;
				}
			}
		}

		public override void OnGain(PlayerUnit player)
		{
			((ShiningExhibit)this).OnGain(player);
			((GameEntity)this).GameRun.GainMaxHp(((Exhibit)this).Value1, true, false);
		}

		public override void OnLose(PlayerUnit player)
		{
			((ShiningExhibit)this).OnLose(player);
			((GameEntity)this).GameRun.LoseMaxHp(((Exhibit)this).Value1, true);
		}

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<CardUsingEventArgs>(((Exhibit)this).Battle.CardUsed, (EventSequencedReactor<CardUsingEventArgs>)OnCardUsed);
			((Exhibit)this).HandleBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Owner).TurnEnding, (GameEventHandler<UnitEventArgs>)delegate
			{
				TrackCounter--;
			});
			((Exhibit)this).HandleBattleEvent<GameEventArgs>(((Exhibit)this).Battle.BattleStarting, (GameEventHandler<GameEventArgs>)delegate
			{
				PlayerUnit owner = ((Exhibit)this).Owner;
				int? num = ((Exhibit)this).Value2;
				int? num2 = 0;
				((GameEntity)this).React(Reactor.op_Implicit((BattleAction)(object)new ApplyStatusEffectAction<BloodyRipperSe>((Unit)(object)owner, num, (int?)null, num2, (int?)null, 0f, true)));
			}, (GameEventPriority)(-50));
			TrackCounter = 0;
		}

		protected override void OnLeaveBattle()
		{
			TrackCounter = 0;
		}

		private IEnumerable<BattleAction> OnCardUsed(CardUsingEventArgs args)
		{
			if (((Exhibit)this).Battle.BattleShouldEnd)
			{
				yield break;
			}
			if ((int)args.Card.CardType == 1)
			{
				TrackCounter++;
				if (TrackCounter >= ((Exhibit)this).Value2)
				{
					((Exhibit)this).NotifyActivating();
					BloodyRipperSe br = default(BloodyRipperSe);
					if (((Unit)((Exhibit)this).Owner).TryGetStatusEffect<BloodyRipperSe>(ref br))
					{
						((StatusEffect)br).NotifyActivating();
					}
					yield return (BattleAction)(object)new ApplyStatusEffectAction<BloodDrainSe>((Unit)(object)((Exhibit)this).Owner, (int?)1, (int?)1, (int?)null, (int?)null, 0f, true);
					TrackCounter = 0;
				}
			}
			if (((GameEntity)args.Card).Id != "Knife")
			{
				int dmg = ((GameEntity)this).GameRun.BattleRng.NextInt(1, 3);
				if (dmg >= ((Unit)((Exhibit)this).Owner).Hp)
				{
					dmg = ((Unit)((Exhibit)this).Owner).Hp - 1;
				}
				yield return (BattleAction)new DamageAction((Unit)(object)((Exhibit)this).Owner, (Unit)(object)((Exhibit)this).Owner, DamageInfo.HpLose((float)dmg, true), "Sacrifice", (GunType)0);
			}
		}
	}
	public sealed class BloodRipperSeDef : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BloodyRipperSe");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.StatusEffectBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourceLoader.LoadSprite("BloodyRipperEx.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}

		public override StatusEffectConfig MakeConfig()
		{
			StatusEffectConfig val = ((StatusEffectTemplate)this).DefaultConfig();
			val.HasLevel = true;
			val.Type = (StatusEffectType)2;
			val.HasCount = true;
			return val;
		}
	}
	[EntityLogic(typeof(BloodRipperSeDef))]
	public sealed class BloodyRipperSe : StatusEffect
	{
	}
	public sealed class ChaoticBloodMagicCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("ChaoticBloodMagicCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)2;
			List<ManaColor> obj = new List<ManaColor> { (ManaColor)4 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			((ManaGroup)(ref val2)).Red = 1;
			ManaGroup val3 = val2;
			int? num = 11;
			int? num2 = 17;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Red = 2;
			ManaGroup? val4 = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Red = 1;
			((ManaGroup)(ref val2)).Philosophy = 1;
			return new CardConfig(0, "", 10, true, array, "RemiZhua", "RemiZhuaB", 0, false, true, true, false, true, (Rarity)0, (CardType)1, val, (IReadOnlyList<ManaColor>)obj, false, val3, (ManaGroup?)null, (int?)null, num, num2, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, val4, (ManaGroup?)val2, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), "Sakuya", "", "", false, "かわやばぐ", (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(ChaoticBloodMagicCardDef))]
	public sealed class ChaoticBloodMagicCard : Card
	{
		protected override void OnEnterBattle(BattleController battle)
		{
			((Card)this).ReactBattleEvent<DieEventArgs>(((Card)this).Battle.EnemyDied, (EventSequencedReactor<DieEventArgs>)OnEnemyDied);
		}

		private IEnumerable<BattleAction> OnEnemyDied(DieEventArgs args)
		{
			if (args.DieSource == this)
			{
				yield return (BattleAction)new GainManaAction(((Card)this).Mana);
			}
		}
	}
	public sealed class ConsequenceOfHickeysCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("ConsequenceOfHickeysCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			return new CardImages(BepinexPlugin.embeddedSource, ResourceLoader.LoadTexture("ConsequencesOfHickeysCard.png", BepinexPlugin.embeddedSource));
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)1;
			List<ManaColor> obj = new List<ManaColor> { (ManaColor)4 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Red = 1;
			ManaGroup val3 = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			return new CardConfig(0, "", 10, true, array, "Simple1", "Simple2", 0, false, true, true, false, true, (Rarity)0, (CardType)1, val, (IReadOnlyList<ManaColor>)obj, false, val3, (ManaGroup?)val2, (int?)null, (int?)3, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)2, (int?)1, (int?)2, (int?)3, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string> { "Knife" }, (IReadOnlyList<string>)new List<string> { "Knife" }, "Sakuya", "", "", false, "@kon_ypaaa", (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(ConsequenceOfHickeysCardDef))]
	public sealed class ConsequenceOfHickeysCard : Card
	{
		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield return (BattleAction)(object)PerformAction.Gun((Unit)(object)((Card)this).Battle.Player, (Unit)(object)((Card)this).Battle.Player, "ESakuyaShoot2", 0f);
			yield return ((Card)this).SacrificeAction(((Card)this).Value1);
			yield return ((Card)this).AttackAction(selector, (GunPair)null);
			yield return (BattleAction)new AddCardsToHandAction((IEnumerable<Card>)Library.CreateCards<Knife>(((Card)this).Value2, false), (AddCardsType)0);
		}
	}
}
namespace VariantsC.Sakuya.C.BunniesCorrection
{
	public sealed class MoonTipsSpacesuitCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("MoonTipsSpacesuitCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			return new CardConfig(0, "", 10, true, new string[0][], "Simple1", "Simple1", 0, false, false, true, true, false, (Rarity)1, (CardType)6, (TargetType?)(TargetType)0, (IReadOnlyList<ManaColor>)new List<ManaColor>(), false, default(ManaGroup), (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)1, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)0, (Keyword)0, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (string)null, "", "", false, "DD/neo", (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(MoonTipsSpacesuitCardDef))]
	public sealed class MoonTipsSpacesuitCard : Card
	{
	}
	public sealed class MoonTipsSpacesuitSeDef : StatusEffectTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("MoonTipsSpacesuitSe");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.StatusEffectBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourcesHelper.TryGetSprite<Exhibit>("Yuhangfu");
		}

		public override StatusEffectConfig MakeConfig()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			return new StatusEffectConfig(0, "", 10, (StatusEffectType)0, false, true, (int?)null, false, (StackType?)(StackType)0, false, (StackType?)(StackType)0, (DurationDecreaseTiming)0, false, (StackType?)(StackType)3, (StackType?)(StackType)3, false, (Keyword)0, (IReadOnlyList<string>)new List<string>(), "Default", "Default", "Default");
		}
	}
	[EntityLogic(typeof(MoonTipsSpacesuitSeDef))]
	public sealed class MoonTipsSpacesuitSe : StatusEffect
	{
		protected override void OnAdded(Unit unit)
		{
			((StatusEffect)this).HandleOwnerEvent<DamageEventArgs>(((StatusEffect)this).Owner.DamageTaking, (GameEventHandler<DamageEventArgs>)OnPlayerDamageTaking);
		}

		private void OnPlayerDamageTaking(DamageEventArgs args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			DamageInfo damageInfo = args.DamageInfo;
			if (MathExtensions.RoundToInt(((DamageInfo)(ref damageInfo)).Damage) > 0)
			{
				((StatusEffect)this).NotifyActivating();
				damageInfo = args.DamageInfo;
				args.DamageInfo = ((DamageInfo)(ref damageInfo)).ReduceActualDamageBy(1);
				((GameEventArgs)args).AddModifier((GameEntity)(object)this);
			}
		}
	}
	[HarmonyPatch]
	internal class MoonTipsBag_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return ExtraAccess.InnerMoveNext(typeof(MoonTipsBag), "Actions");
		}

		public static bool DoPatch()
		{
			GameMaster instance = Singleton<GameMaster>.Instance;
			bool? obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameRunController currentGameRun = instance.CurrentGameRun;
				if (currentGameRun == null)
				{
					obj = null;
				}
				else
				{
					PlayerUnit player = currentGameRun.Player;
					obj = ((player != null) ? new bool?(player.HasExhibit<BloodyRipperEx>()) : null);
				}
			}
			bool? flag = obj;
			return flag.GetValueOrDefault();
		}

		private static void CreateNewOption(List<Card> list)
		{
			if (DoPatch())
			{
				list.Add((Card)(object)Library.CreateCard<MoonTipsSpacesuitCard>());
			}
		}

		private static bool CheckOption(Card card, MoonTipsBag moonTipsBag)
		{
			if (card is MoonTipsSpacesuitCard)
			{
				((Card)moonTipsBag).Battle.RequestDebugAction(((Card)moonTipsBag).BuffAction<MoonTipsSpacesuitSe>(0, 0, 0, 0, 0.2f), "Special Moon Tip");
				return true;
			}
			return false;
		}

		private static IEnumerable<CodeInstruction> Transpiler(MethodBase original, IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			Label label = default(Label);
			return new CodeMatcher(instructions, generator).End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(OpCodes.Ldarg_0) }).CreateLabel(ref label)
				.Start()
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Library), "CreateCard", new Type[0], (Type[])null).MakeGenericMethod(typeof(MoonTipsHeal)))) })
				.Advance(2)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Dup, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MoonTipsBag_Patch), "CreateNewOption", (Type[])null, (Type[])null))
				})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1] { CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(MiniSelectCardInteraction), "SelectedCard"))) })
				.Advance(2)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_3, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_1, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(MoonTipsBag_Patch), "CheckOption", (Type[])null, (Type[])null))
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				})
				.InstructionEnumeration();
		}
	}
}
namespace VariantsC.Rng
{
	public class PerRngs
	{
		[YamlIgnore]
		private static ConditionalWeakTable<GameRunController, PerRngs> table = new ConditionalWeakTable<GameRunController, PerRngs>();

		public RandomGen everHoardingRng;

		public RandomGen springCleaningRng;

		public static PerRngs Get(GameRunController gr)
		{
			return table.GetOrCreateValue(gr);
		}

		public static void Assign(GameRunController gr, PerRngs persistentRngs)
		{
			table.AddOrUpdate(gr, persistentRngs);
		}

		public void InitRngs(RandomGen rng)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			RandomGen val = new RandomGen(rng.NextULong());
			everHoardingRng = new RandomGen(val.NextULong());
			springCleaningRng = new RandomGen(val.NextULong());
		}
	}
	[HarmonyPatch]
	[HarmonyPriority(200)]
	internal class Gr_cctor_Patch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Constructor(typeof(GameRunController), new Type[1] { typeof(GameRunStartupParameters) }, false);
		}

		private static void Postfix(GameRunController __instance)
		{
			PerRngs.Get(__instance).InitRngs(__instance.RootRng);
		}
	}
	public class SaveContainer : CustomGameRunSaveData
	{
		public PerRngs persistentRngs;

		public override void Restore(GameRunController gameRun)
		{
			PerRngs.Assign(gameRun, persistentRngs);
		}

		public override void Save(GameRunController gameRun)
		{
			persistentRngs = PerRngs.Get(gameRun);
		}

		public override IEnumerable<IYamlTypeConverter> TypeConverters()
		{
			yield return (IYamlTypeConverter)new RandomGenTypeConverter();
		}
	}
}
namespace VariantsC.Reimu.C
{
	public sealed class ChocolateCoinExDef : ExhibitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("ChocolateCoinEx");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.ExhibitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ExhibitSprites LoadSprite()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			return new ExhibitSprites(ResourceLoader.LoadSprite("ChocolateCoinEx.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null));
		}

		public override ExhibitConfig MakeConfig()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			return new ExhibitConfig(0, "", -5, false, false, false, false, (AppearanceType)0, "Reimu", (ExhibitLosableType)1, (Rarity)3, (int?)4, (int?)null, (int?)null, (ManaGroup?)null, (ManaColor?)null, (ManaColor?)(ManaColor)6, 1, true, (int?)null, (Keyword)65538, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(ChocolateCoinExDef))]
	public sealed class ChocolateCoinEx : ShiningExhibit
	{
		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Battle.Player).TurnStarting, (EventSequencedReactor<UnitEventArgs>)OnTurnStarting);
			((Exhibit)this).Counter = ((Exhibit)this).Value1;
		}

		protected override void OnLeaveBattle()
		{
			((Exhibit)this).Counter = 0;
		}

		private IEnumerable<BattleAction> OnTurnStarting(UnitEventArgs args)
		{
			if (((Exhibit)this).Counter <= 0)
			{
				yield break;
			}
			IEnumerable<Card> basics = ((Exhibit)this).Battle.DrawZone.Where((Card c) => c.IsBasic);
			if (basics.Count() == 0)
			{
				basics = ((Exhibit)this).Battle.DiscardZone.Where((Card c) => c.IsBasic);
			}
			if (basics.Count() == 0)
			{
				basics = ((Exhibit)this).Battle.HandZone.Where((Card c) => c.IsBasic);
			}
			if (basics.Count() > 0)
			{
				((Exhibit)this).NotifyActivating();
				yield return (BattleAction)new ExileCardAction(CollectionsExtensions.Sample<Card>(basics, ((GameEntity)this).GameRun.BattleRng));
			}
			int counter = ((Exhibit)this).Counter;
			((Exhibit)this).Counter = counter - 1;
		}
	}
	public sealed class JabReimuCUltDef : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("JabReimuCUlt");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.UltimateSkillBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourceLoader.LoadSprite("reimu_fist.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}

		public override UltimateSkillConfig MakeConfig()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 45, 45, 5, (UsRepeatableType)0, 13, 0, 0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(JabReimuCUltDef))]
	public sealed class JabReimuCUlt : UltimateSkill
	{
		public override DamageInfo Damage => DamageInfo.Attack((float)((UltimateSkill)this).Config.Damage, false);

		public JabReimuCUlt()
		{
			((UltimateSkill)this).TargetType = (TargetType)1;
			((UltimateSkill)this).GunName = "博丽一拳";
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)new DamageAction((Unit)(object)((UltimateSkill)this).Owner, (Unit)(object)selector.GetEnemy(((UltimateSkill)this).Battle), ((UltimateSkill)this).Damage, ((UltimateSkill)this).GunName, (GunType)0);
		}
	}
	public sealed class RollingPebbleCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("RollingPebbleCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)1;
			List<ManaColor> obj = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			return new CardConfig(0, "", 10, true, array, "ENitoriShoot1", "", 0, false, true, true, false, true, (Rarity)0, (CardType)1, val, (IReadOnlyList<ManaColor>)obj, false, val2, (ManaGroup?)null, (int?)null, (int?)6, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)5, (int?)null, (int?)null, (int?)null, (ManaGroup?)null, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)2147483648u, (Keyword)2147483904u, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), "Koishi", "", "", false, "わらび餅", (IReadOnlyList<string>)new List<string> { "minato_hitori" });
		}
	}
	[EntityLogic(typeof(RollingPebbleCardDef))]
	public sealed class RollingPebbleCard : Card
	{
		private int extraDmg = 0;

		public override DamageInfo Damage => CalcDmg();

		protected override void OnLeaveBattle()
		{
			extraDmg = 0;
		}

		private DamageInfo CalcDmg()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			return DamageInfo.Attack((float)(((Card)this).RawDamage + extraDmg), ((Card)this).IsAccuracy);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (((Card)this).IsUpgraded)
			{
				extraDmg += ((Card)this).Value1 * ((Card)this).SynergyAmount(consumingMana, (ManaColor)0, 1);
			}
			string gun = ((Card)this).GunName;
			DamageInfo damage = ((Card)this).Damage;
			if (((DamageInfo)(ref damage)).Amount >= 30f)
			{
				gun = "ENitoriShoot2";
			}
			yield return ((Card)this).AttackAction((IEnumerable<Unit>)selector.GetUnits(((Card)this).Battle), gun, CalcDmg());
			if (!((Card)this).IsUpgraded)
			{
				extraDmg += ((Card)this).Value1 * ((Card)this).SynergyAmount(consumingMana, (ManaColor)0, 1);
			}
		}
	}
}
namespace VariantsC.Marisa.C
{
	[OverwriteVanilla]
	public sealed class AntiStallOrbDef : EnemyUnitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("YinyangyuBlue");
		}

		[DontOverwrite]
		public override LocalizationOption LoadLocalization()
		{
			throw new NotImplementedException();
		}

		[DontOverwrite]
		public override EnemyUnitConfig MakeConfig()
		{
			throw new NotImplementedException();
		}
	}
	[EntityLogic(typeof(AntiStallOrbDef))]
	public sealed class YinyangyuBlue : YinyangyuBlueOrigin
	{
		private enum ExplodeSequence
		{
			Dont,
			Charge,
			Explode
		}

		private ExplodeSequence explodeSequence = ExplodeSequence.Dont;

		public override void OnEnterBattle(BattleController battle)
		{
			((Unit)this).HandleBattleEvent<DamageEventArgs>(((Unit)this).DamageReceived, (GameEventHandler<DamageEventArgs>)delegate
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				Intention? obj = ((IEnumerable<Intention>)((EnemyUnit)this).Intentions).FirstOrDefault((Func<Intention, bool>)((Intention i) => i is ExplodeIntention));
				ExplodeIntention val = (ExplodeIntention)(object)((obj is ExplodeIntention) ? obj : null);
				if (val != null)
				{
					val.Damage = DamageInfo.Attack((float)((Unit)this).Shield, false);
					((EnemyUnit)this).NotifyIntentionsChanged();
				}
			});
			((YinyangyuBlueOrigin)this).OnEnterBattle(battle);
		}

		public override void UpdateMoveCounters()
		{
			Spirit val = default(Spirit);
			if (explodeSequence == ExplodeSequence.Charge)
			{
				explodeSequence = ExplodeSequence.Explode;
			}
			else if (((GameEntity)this).GameRun.Player.HasExhibit<PachyBagEx>() && ((Unit)this).TryGetStatusEffect<Spirit>(ref val) && ((StatusEffect)val).Level >= 16 && ((Unit)this).Battle.AllAliveEnemies.All((EnemyUnit e) => e is YinyangyuBlueOrigin))
			{
				explodeSequence = ExplodeSequence.Charge;
			}
			else
			{
				((YinyangyuBlueOrigin)this).UpdateMoveCounters();
			}
		}

		public override IEnumerable<IEnemyMove> GetTurnMoves()
		{
			switch (explodeSequence)
			{
			case ExplodeSequence.Charge:
				yield return (IEnemyMove)new SimpleEnemyMove(Intention.Unknown(), (BattleAction)new EnemyMoveAction((EnemyUnit)(object)this, ((EnemyUnit)this).GetMove(0), true));
				yield break;
			case ExplodeSequence.Explode:
				yield return (IEnemyMove)new SimpleEnemyMove(Intention.Explode(((Unit)this).Shield), ExplodeAction());
				yield break;
			}
			foreach (IEnemyMove item in <>n__0())
			{
				yield return item;
			}
		}

		private IEnumerable<BattleAction> ExplodeAction()
		{
			yield return (BattleAction)new ExplodeAction((EnemyUnit)(object)this, (Unit)(object)((Unit)this).Battle.Player, DamageInfo.Attack((float)((Unit)this).Shield, false), (DieCause)4, (GameEntity)(object)this, "GuihuoExplodeB2", (GunType)0);
		}

		[CompilerGenerated]
		[DebuggerHidden]
		private IEnumerable<IEnemyMove> <>n__0()
		{
			return ((YinyangyuBlueOrigin)this).GetTurnMoves();
		}
	}
	public sealed class EverHoardingCardDef : CardTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("EverHoardingCard");
		}

		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)0;
			List<ManaColor> obj = new List<ManaColor> { (ManaColor)5 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Green = 1;
			ManaGroup val3 = val2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Green = 1;
			((ManaGroup)(ref val2)).Any = 2;
			ManaGroup? val4 = val2;
			int? num = 3;
			int? num2 = 2;
			val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Any = 1;
			return new CardConfig(0, "", 10, true, array, "", "", 0, false, true, false, false, true, (Rarity)2, (CardType)4, val, (IReadOnlyList<ManaColor>)obj, false, val3, val4, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, num, num2, (int?)null, (int?)null, (ManaGroup?)val2, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)2097152, (Keyword)3145728, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), "Marisa", "", "", false, "porokin", (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(EverHoardingCardDef))]
	public sealed class EverHoardingCard : Card
	{
		[HarmonyPatch(typeof(Card), "Verify")]
		private class DoNotVerify_Patch
		{
			private static bool Prefix(Card __instance)
			{
				if (__instance is EverHoardingCard)
				{
					return false;
				}
				return true;
			}
		}

		private int _cardCounter = 0;

		public readonly float rareWMult = 1.15f;

		public readonly float uncommonWMult = 0.95f;

		public int CardCounter
		{
			get
			{
				return _cardCounter;
			}
			set
			{
				_cardCounter = value % (((Card)this).Value1 + 1);
			}
		}

		public string CardCounterWrap => (((Card)this).Battle == null) ? "" : $"{{<color=#B2FFFF>{CardCounter}</color>}} ";

		public string JustName => ((Card)this).LocalizeProperty("JustName", false, true);

		public string JustNameBlue => StringDecorator.GetEntityName(JustName);

		public override string Name => RuntimeFormatterExtensions.RuntimeFormat(((GameEntity)this).Name, ((GameEntity)this).FormatWrapper);

		public int MaxGen => 13;

		public int GenAmount
		{
			get
			{
				//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)
				ManaGroup cost = ((Card)this).Cost;
				return _GenAmount(((ManaGroup)(ref cost)).Amount);
			}
		}

		public string CommonColor => CardColors.common;

		public string CommonChance
		{
			get
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup cost = ((Card)this).Cost;
				RarityWeightTable dynamicRarityTable = GetDynamicRarityTable(GetRarityX(((ManaGroup)(ref cost)).Amount));
				return $"{dynamicRarityTable.Common:F2}";
			}
		}

		public string UncommonColor => CardColors.uncommon;

		public string UncommonChance
		{
			get
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup cost = ((Card)this).Cost;
				RarityWeightTable dynamicRarityTable = GetDynamicRarityTable(GetRarityX(((ManaGroup)(ref cost)).Amount));
				return $"{dynamicRarityTable.Uncommon:F2}";
			}
		}

		public string RareColor => CardColors.rare;

		public string RareChance
		{
			get
			{
				//IL_0004: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup cost = ((Card)this).Cost;
				RarityWeightTable dynamicRarityTable = GetDynamicRarityTable(GetRarityX(((ManaGroup)(ref cost)).Amount));
				return $"{dynamicRarityTable.Rare:F2}";
			}
		}

		public override void Initialize()
		{
			((Card)this).Initialize();
			CardCounter = ((Card)this).Value1;
		}

		protected override void OnEnterBattle(BattleController battle)
		{
			CardCounter = ((Card)this).Value1;
			((Card)this).HandleBattleEvent<CardUsingEventArgs>(((Card)this).Battle.CardUsed, (GameEventHandler<CardUsingEventArgs>)delegate
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				if ((int)((Card)this).Zone == 2)
				{
					CardCounter--;
					((GameEntity)this).NotifyChanged();
					if (CardCounter <= 0)
					{
						((Card)this).IncreaseBaseCost(((Card)this).Mana);
						CardCounter = ((Card)this).Value1;
						((Card)this).NotifyActivating();
					}
				}
			}, (GameEventPriority)0);
		}

		public override void Upgrade()
		{
			((Card)this).Upgrade();
			if (((Card)this).Battle == null)
			{
				CardCounter = ((Card)this).Value1;
			}
			((GameEntity)this).NotifyChanged();
		}

		protected override IReadOnlyList<string> LocalizeListProperty(string key, bool required = true)
		{
			return ((Card)this).LocalizeListProperty(key, required);
		}

		private RarityWeightTable GetDynamicRarityTable(int amount)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			double num = 1.0;
			double num2 = Math.Clamp(num * (1.0 / (1.0 + Math.Exp(-0.3 * (double)(amount - 11)))), 0.0, 0.699999988079071);
			num -= num2;
			double num3 = Math.Clamp(num * (double)((float)amount / 9f) * 0.8999999761581421, 0.0, num);
			num -= num3;
			double num4 = Math.Clamp(num, 0.0, 1.0);
			return new RarityWeightTable(MathExtensions.ToFloat(num4), MathExtensions.ToFloat(num3), MathExtensions.ToFloat(num2), 0f);
		}

		private int GetRarityX(int x)
		{
			return x - 1;
		}

		public int _GenAmount(int x)
		{
			return Math.Clamp(x - 1, 0, MaxGen);
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int genAmount = _GenAmount(((ManaGroup)(ref consumingMana)).Amount);
			if (genAmount > 0)
			{
				CardWeightTable cardWTable = new CardWeightTable(GetDynamicRarityTable(GetRarityX(((ManaGroup)(ref consumingMana)).Amount)), OwnerWeightTable.Hierarchy, CardTypeWeightTable.CanBeLoot, false);
				Card[] cards2 = ((GameEntity)this).GameRun.RollCards(PerRngs.Get(((GameEntity)this).GameRun).everHoardingRng, cardWTable, genAmount, false, true, (Predicate<CardConfig>)null);
				yield return (BattleAction)(object)new ProcessDeckCardsAction(cards2, delegate(IEnumerable<Card> cards)
				{
					((GameEntity)this).GameRun.AddDeckCards(cards, true, (VisualSourceData)null);
				}, "Gained")
				{
					batchSize = 7,
					batchDelay = 0.35f,
					finalDelay = 0f
				};
			}
		}
	}
	public abstract class NodeData
	{
		public abstract string Key { get; }
	}
	public class CardData : NodeData
	{
		public List<Card> cards = new List<Card>();

		public override string Key => "CardData";
	}
	public sealed class PachyBagExDef : ExhibitTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("PachyBagEx");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.ExhibitBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override ExhibitSprites LoadSprite()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			return new ExhibitSprites(ResourceLoader.LoadSprite("PachyBagEx.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null));
		}

		public override ExhibitConfig MakeConfig()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			return new ExhibitConfig(0, "", 10, false, false, false, false, (AppearanceType)0, "Marisa", (ExhibitLosableType)2, (Rarity)3, (int?)30, (int?)2, (int?)null, (ManaGroup?)null, (ManaColor?)null, (ManaColor?)(ManaColor)5, 1, true, (int?)null, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(PachyBagExDef))]
	public sealed class PachyBagEx : ShiningExhibit
	{
		public int ExtraMana => ((GameEntity)this).GameRun.BaseDeck.Count / ((Exhibit)this).Value1;

		protected override void OnAdded(PlayerUnit player)
		{
			((Exhibit)this).HandleGameRunEvent<CardsEventArgs>(((GameEntity)this).GameRun.DeckCardsAdded, (GameEventHandler<CardsEventArgs>)UpdateCounter);
			((Exhibit)this).HandleGameRunEvent<CardsEventArgs>(((GameEntity)this).GameRun.DeckCardsRemoved, (GameEventHandler<CardsEventArgs>)UpdateCounter);
			((Exhibit)this).HandleGameRunEvent<StationEventArgs>(((GameEntity)this).GameRun.StationRewardGenerating, (GameEventHandler<StationEventArgs>)delegate(StationEventArgs args)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Invalid comparison between Unknown and I4
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Invalid comparison between Unknown and I4
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Expected O, but got Unknown
				Station station = args.Station;
				if ((int)station.Type == 1)
				{
					((Exhibit)this).NotifyActivating();
					station.Rewards.Add(station.Stage.GetEnemyCardReward());
				}
				else
				{
					if ((int)station.Type != 2)
					{
						AdventureStation val = (AdventureStation)(object)((station is AdventureStation) ? station : null);
						if (val == null || !(val.Adventure is YachieOppression))
						{
							goto IL_0082;
						}
					}
					((Exhibit)this).NotifyActivating();
					station.Rewards.Add(station.Stage.GetEliteEnemyCardReward());
				}
				goto IL_0082;
				IL_0082:
				foreach (StationReward item in station.Rewards.FindAll(delegate(StationReward re)
				{
					List<Card> cards = re.Cards;
					return cards != null && cards.Count >= 2;
				}))
				{
					int count = item.Cards.Count;
					List<int> list = Enumerable.Range(0, Math.Max(10, count)).ToList();
					RandomGen val2 = new RandomGen(((GameEntity)this).GameRun.GameRunEventRng.NextULong());
					CollectionsExtensions.Shuffle<int>((IList<int>)list, val2);
					HashSet<Card> toRemove = new HashSet<Card>();
					int num = ((count - ((Exhibit)this).Value2 < 1) ? 1 : ((Exhibit)this).Value2);
					foreach (int item2 in list)
					{
						if (item2 < count)
						{
							toRemove.Add(item.Cards[item2]);
							if (toRemove.Count >= num)
							{
								break;
							}
						}
					}
					item.Cards.RemoveAll((Card c) => toRemove.Contains(c));
				}
			}, (GameEventPriority)99);
		}

		private void UpdateCounter(CardsEventArgs args)
		{
			int counter = ((Exhibit)this).Counter;
			((Exhibit)this).Counter = ExtraMana;
			if (((Exhibit)this).Counter != counter)
			{
				((Exhibit)this).NotifyActivating();
			}
		}

		protected override void OnEnterBattle()
		{
			((Exhibit)this).ReactBattleEvent<UnitEventArgs>(((Unit)((Exhibit)this).Owner).TurnStarted, (EventSequencedReactor<UnitEventArgs>)OnOwnerTurnStarted);
			((Exhibit)this).HandleBattleEvent<GameEventArgs>(((Exhibit)this).Battle.BattleStarting, (GameEventHandler<GameEventArgs>)OnBattleStarting, (GameEventPriority)(-99));
		}

		private void OnBattleStarting(GameEventArgs args)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			int num = (((Exhibit)this).Battle.DrawZone.Count - 1) / 2 + 1;
			Card[] subArray = ((Exhibit)this).Battle.DrawZone.ToArray()[..(num + 1)];
			CollectionsExtensions.Shuffle<Card>((IList<Card>)subArray, new RandomGen(((GameEntity)this).GameRun.BattleCardRng.NextULong()));
			((Exhibit)this).Battle._drawZone.RemoveRange(0, subArray.Length);
			List<Card> collection = ((Exhibit)this).Battle.DrawZone.ToList();
			((Exhibit)this).Battle._drawZone.Clear();
			((Exhibit)this).Battle._drawZone.AddRange(subArray);
			((Exhibit)this).Battle._drawZone.AddRange(collection);
		}

		private IEnumerable<BattleAction> OnOwnerTurnStarted(UnitEventArgs args)
		{
			for (int i = 0; i < ExtraMana; i++)
			{
				((Exhibit)this).NotifyActivating();
				ManaGroup manaGroup = ManaGroup.Single(CollectionsExtensions.Sample<ManaColor>((IEnumerable<ManaColor>)ManaColors.Colors, ((GameEntity)this).GameRun.BattleRng));
				yield return (BattleAction)new GainManaAction(manaGroup);
			}
		}
	}
	public abstract class RootRandomStartersDef : CardTemplate
	{
		public override CardImages LoadCardImages()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			CardImages val = new CardImages(BepinexPlugin.embeddedSource);
			val.AutoLoad((CardTemplate)(object)this, ".png", "", false);
			return val;
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.CardBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override CardConfig MakeConfig()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			string[][] array = new string[0][];
			TargetType? val = (TargetType)0;
			List<ManaColor> obj = new List<ManaColor> { (ManaColor)6 };
			ManaGroup val2 = default(ManaGroup);
			((ManaGroup)(ref val2)).Colorless = 1;
			ManaGroup val3 = val2;
			val2 = default(ManaGroup);
			return new CardConfig(0, "", 10, true, array, "", "", 0, false, false, false, true, false, (Rarity)0, (CardType)3, val, (IReadOnlyList<ManaColor>)obj, false, val3, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (ManaGroup?)val2, (ManaGroup?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (int?)null, (Keyword)2, (Keyword)2, false, (Keyword)0, (Keyword)0, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>(), "Marisa", "", "", false, "", (IReadOnlyList<string>)new List<string>());
		}
	}
	public class RootRandomStarter : Card
	{
		public static RandomGen transformRng;

		public virtual RandomPoolEntry<Type[]>[] PotentialCardTypes { get; }

		public string ListCards => string.Join(";\n", from rp in PotentialCards()
			select string.Join(", ", rp.Elem.Select((Card c) => UiUtils.WrapByColor(((GameEntity)c).Name, GlobalConfig.DefaultKeywordColor)))) + ";";

		public string AddTimesWrap => (AddTimes <= 1) ? "" : $" <b>{{X{AddTimes}}}</b>";

		public virtual int AddTimes => 1;

		public string JustName => ((Card)this).LocalizeProperty("JustName", false, true);

		public string JustNameBlue => StringDecorator.GetEntityName(JustName);

		public override string Name => RuntimeFormatterExtensions.RuntimeFormat(((GameEntity)this).Name, ((GameEntity)this).FormatWrapper);

		public override void Initialize()
		{
			((Card)this).Initialize();
			((Card)this).Config.RelativeCards = new List<string>((from t in PotentialCardTypes.SelectMany((RandomPoolEntry<Type[]> rp) => rp.Elem)
				select t.Name).Distinct());
		}

		public IEnumerable<RandomPoolEntry<List<Card>>> PotentialCards(GameRunController gr = null)
		{
			return PotentialCardTypes.Select(delegate(RandomPoolEntry<Type[]> rp)
			{
				List<Card> list = new List<Card>();
				Type[] elem = rp.Elem;
				foreach (Type type in elem)
				{
					Card val = Library.CreateCard(type);
					((GameEntity)val).GameRun = gr;
					list.Add(val);
				}
				return new RandomPoolEntry<List<Card>>(list, rp.Weight);
			});
		}

		protected override string LocalizeProperty(string key, bool decorated = false, bool required = true)
		{
			if (key == "Description")
			{
				return TypeFactory<Card>.LocalizeProperty("FakePackForCommonLoc", key, decorated, required);
			}
			if (key == "Name")
			{
				return TypeFactory<Card>.LocalizeProperty("FakePackForCommonLoc", "Name", decorated, required);
			}
			return ((Card)this).LocalizeProperty(key, decorated, required);
		}

		public void OnGrStarted(GameRunController gr)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			gr.RemoveDeckCard((Card)(object)this, false);
			if (transformRng == null)
			{
				transformRng = new RandomGen(gr.CardRng.NextULong());
			}
			RepeatableRandomPool<List<Card>> val = new RepeatableRandomPool<List<Card>>();
			val.AddRange(PotentialCards(gr));
			for (int i = 0; i < AddTimes; i++)
			{
				gr.AddDeckCards(from c in val.Sample(transformRng)
					select c.Clone(false), false, (VisualSourceData)null);
			}
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector, ManaGroup consumingMana, Interaction precondition)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			yield break;
		}
	}
	[HarmonyPatch]
	[HarmonyPriority(100)]
	internal class GrStartEvents
	{
		public static List<Action<GameRunController>> onGrStarted = new List<Action<GameRunController>>();

		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Constructor(typeof(GameRunController), new Type[1] { typeof(GameRunStartupParameters) }, false);
		}

		private static void Prefix(GameRunStartupParameters startupParameters)
		{
			onGrStarted.Clear();
			RootRandomStarter.transformRng = null;
			CollectionExtensions.Do<RootRandomStarter>(startupParameters.Deck.Where((Card c) => c is RootRandomStarter).Cast<RootRandomStarter>(), (Action<RootRandomStarter>)delegate(RootRandomStarter sp)
			{
				onGrStarted.Add(sp.OnGrStarted);
			});
		}

		private static void Postfix(GameRunController __instance)
		{
			CollectionExtensions.Do<Action<GameRunController>>((IEnumerable<Action<GameRunController>>)onGrStarted, (Action<Action<GameRunController>>)delegate(Action<GameRunController> a)
			{
				a(__instance);
			});
		}
	}
	public sealed class SpringCleaningUltDef : UltimateSkillTemplate
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("SpringCleaningUlt");
		}

		public override LocalizationOption LoadLocalization()
		{
			return (LocalizationOption)(object)BepinexPlugin.UltimateSkillBatchLoc.AddEntity((EntityDefinition)(object)this);
		}

		public override Sprite LoadSprite()
		{
			return ResourceLoader.LoadSprite("SpringCleaningUlt.png", BepinexPlugin.embeddedSource, (Rect?)null, 1, (Vector2?)null);
		}

		public override UltimateSkillConfig MakeConfig()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			return new UltimateSkillConfig("", 10, 200, 200, 1, (UsRepeatableType)2, 0, 7, 2, (Keyword)70368744177664L, (IReadOnlyList<string>)new List<string>(), (IReadOnlyList<string>)new List<string>());
		}
	}
	[EntityLogic(typeof(SpringCleaningUltDef))]
	public sealed class SpringCleaningUlt : UltimateSkill
	{
		private ManaGroup _mana;

		public ManaGroup Mana => _mana;

		public int HalfDeck => Math.Min(((GameEntity)this).GameRun.BaseDeck.Count / 2, ((GameEntity)this).GameRun.BaseDeckWithOutUnremovable.Where((Card c) => !c.IsUpgraded).Count());

		public string HalfDeckWrap => (((GameEntity)this).GameRun == null) ? ((GameEntity)this).LocalizeProperty("Several", false, true) : $"<color=#B2FFFF>{HalfDeck}</color>";

		public int ToRemove => HalfDeck / 2;

		public string ToRemoveWrap => (((GameEntity)this).GameRun == null) ? "" : $"(<color=#B2FFFF>{ToRemove}</color>)";

		public int ToUpgrade => (HalfDeck - ToRemove - 1) / 2 + 1;

		public string ToUpgradeWrap => (((GameEntity)this).GameRun == null) ? "" : $"(<color=#B2FFFF>{ToUpgrade}</color>)";

		public SpringCleaningUlt()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			ManaGroup mana = default(ManaGroup);
			((ManaGroup)(ref mana)).Philosophy = 3;
			_mana = mana;
			((UltimateSkill)this)..ctor();
			((UltimateSkill)this).TargetType = (TargetType)4;
		}

		protected override IEnumerable<BattleAction> Actions(UnitSelector selector)
		{
			yield return (BattleAction)(object)PerformAction.Spell((Unit)(object)((UltimateSkill)this).Owner, ((GameEntity)this).Id);
			yield return (BattleAction)(object)PerformAction.Effect((Unit)(object)((UltimateSkill)this).Owner, "MoonG", 0f, "MarisaBottleLaunch", 0f, (EffectBehavior)0, 0f);
			RandomGen subRootRng = new RandomGen(PerRngs.Get(((GameEntity)this).GameRun).springCleaningRng.NextULong());
			List<Card> selected = (from c in ((GameEntity)this).GameRun.BaseDeckWithOutUnremovable
				where ((GameEntity)c).Id != "EverHoardingCard" && !c.IsUpgraded
				group c by c.IsUpgraded.ToInt() into g
				orderby g.Key
				select g).Select(delegate(IGrouping<int, Card> g)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				List<Card> list = g.ToList();
				CollectionsExtensions.Shuffle<Card>((IList<Card>)list, new RandomGen(subRootRng.NextULong()));
				return list;
			}).SelectMany((List<Card> l) => l).Take(HalfDeck)
				.ToList();
			Card[] cardsToRemove = selected.GetRange(0, ToRemove).ToArray();
			HashSet<int> cardsToRemoveIdSet = cardsToRemove.Select((Card c) => c.InstanceId).ToHashSet();
			Card[] cardsToUpgrade = (from c in selected.GetRange(ToRemove, selected.Count - ToRemove)
				where c.CanUpgradeAndPositive
				select c).Take(ToUpgrade).ToArray();
			HashSet<int> cardsToUpgradeIdSet = cardsToUpgrade.Select((Card c) => c.InstanceId).ToHashSet();
			yield return (BattleAction)(object)new ProcessDeckCardsAction(cardsToRemove, delegate(IEnumerable<Card> cards)
			{
				((GameEntity)this).GameRun.RemoveDeckCards(cards, true);
			}, "Removed");
			yield return (BattleAction)(object)new ProcessDeckCardsAction(cardsToUpgrade, delegate(IEnumerable<Card> cards)
			{
				((GameEntity)this).GameRun.UpgradeDeckCards(cards, true);
			}, "Upgraded");
			foreach (Card c2 in ((UltimateSkill)this).Battle.EnumerateAllCards().ToList())
			{
				if (cardsToRemoveIdSet.Contains(c2.InstanceId))
				{
					yield return (BattleAction)new RemoveCardAction(c2);
				}
				else if (cardsToUpgradeIdSet.Contains(c2.InstanceId) && c2.CanUpgrade)
				{
					c2.Upgrade();
				}
			}
			Card misfortune = ((GameEntity)this).GameRun.GetRandomCurseCard(subRootRng, true);
			((GameEntity)this).GameRun.AddDeckCard(misfortune, true, (VisualSourceData)null);
			yield return (BattleAction)new DiscardManyAction((IEnumerable<Card>)((UltimateSkill)this).Battle.HandZone);
			yield return (BattleAction)(object)new StackDrawToDiscard();
			yield return (BattleAction)new DrawManyCardAction(((UltimateSkill)this).Value1);
			yield return (BattleAction)new GainManaAction(Mana);
		}

		private IEnumerator ProcessManyCards(Card[] cards, Action<IEnumerable<Card>> proccessAction, float finalDelay)
		{
			int batchSize = 5;
			for (int i = 0; i < cards.Length; i += batchSize)
			{
				int upper = Math.Min(cards.Length, i + batchSize);
				Card[] display = cards[i..upper];
				proccessAction(display);
				if (upper < cards.Length)
				{
					yield return (object)new WaitForSecondsRealtime(0.5f + 0.2f * (float)batchSize);
				}
			}
			yield return (object)new WaitForSecondsRealtime(finalDelay);
		}
	}
	public sealed class FakePackForCommonLocDef : RootRandomStartersDef
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("FakePackForCommonLoc");
		}

		public override CardImages LoadCardImages()
		{
			return null;
		}
	}
	[EntityLogic(typeof(FakePackForCommonLocDef))]
	public sealed class FakePackForCommonLoc : Card
	{
	}
	public sealed class BasicTreasurePackDef : RootRandomStartersDef
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BasicTreasurePack");
		}

		public override CardConfig MakeConfig()
		{
			CardConfig val = base.MakeConfig();
			val.Illustrator = "lif";
			return val;
		}
	}
	[EntityLogic(typeof(BasicTreasurePackDef))]
	public sealed class BasicTreasurePack : RootRandomStarter
	{
		public override int AddTimes => 1;

		public override RandomPoolEntry<Type[]>[] PotentialCardTypes => new RandomPoolEntry<Type[]>[2]
		{
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(JungleMaster) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[2]
			{
				typeof(Astrology),
				typeof(Astrology)
			}, 1f)
		};
	}
	public sealed class BasicAttacksPackDef : RootRandomStartersDef
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BasicAttacksPack");
		}

		public override CardConfig MakeConfig()
		{
			CardConfig val = base.MakeConfig();
			val.Illustrator = "鬼针草";
			return val;
		}
	}
	[EntityLogic(typeof(BasicAttacksPackDef))]
	public sealed class BasicAttacksPack : RootRandomStarter
	{
		public override int AddTimes => 4;

		public override RandomPoolEntry<Type[]>[] PotentialCardTypes => new RandomPoolEntry<Type[]>[6]
		{
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(MarisaAttackB) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(MarisaAttackR) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(Shoot) }, 1.2f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(BalancedBasicCard) }, 0.8f),
			new RandomPoolEntry<Type[]>(new Type[2]
			{
				typeof(Shoot),
				typeof(Shoot)
			}, 0.5f),
			new RandomPoolEntry<Type[]>(new Type[3]
			{
				typeof(MarisaAttackB),
				typeof(MarisaAttackR),
				typeof(BalancedBasicCard)
			}, 0.2f)
		};
	}
	public sealed class BasicDefencePackDef : RootRandomStartersDef
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BasicDefencePack");
		}

		public override CardConfig MakeConfig()
		{
			CardConfig val = base.MakeConfig();
			val.Illustrator = "@kyotyanehh";
			return val;
		}
	}
	[EntityLogic(typeof(BasicDefencePackDef))]
	public sealed class BasicDefencePack : RootRandomStarter
	{
		public override int AddTimes => 6;

		public override RandomPoolEntry<Type[]>[] PotentialCardTypes => new RandomPoolEntry<Type[]>[6]
		{
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(MarisaBlockB) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(MarisaBlockR) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(Boundary) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(BalancedBasicCard) }, 0.75f),
			new RandomPoolEntry<Type[]>(new Type[2]
			{
				typeof(Boundary),
				typeof(BalancedBasicCard)
			}, 0.35f),
			new RandomPoolEntry<Type[]>(new Type[3]
			{
				typeof(Boundary),
				typeof(Boundary),
				typeof(Boundary)
			}, 0.2f)
		};
	}
	public sealed class BasicMyseryPackDef : RootRandomStartersDef
	{
		public override IdContainer GetId()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return IdContainer.op_Implicit("BasicMiseryPack");
		}

		public override CardConfig MakeConfig()
		{
			CardConfig val = base.MakeConfig();
			val.Illustrator = "ル一キ一ドリフト";
			return val;
		}
	}
	[EntityLogic(typeof(BasicMyseryPackDef))]
	public sealed class BasicMiseryPack : RootRandomStarter
	{
		public override int AddTimes => 3;

		public override RandomPoolEntry<Type[]>[] PotentialCardTypes => new RandomPoolEntry<Type[]>[7]
		{
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(Yueguang) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(Riguang) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(Shadow) }, 1f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(BlackResidue) }, 0.8f),
			new RandomPoolEntry<Type[]>(new Type[1] { typeof(WolfFur) }, 0.75f),
			new RandomPoolEntry<Type[]>(new Type[2]
			{
				typeof(Xingguang),
				typeof(HatateNews)
			}, 0.8f),
			new RandomPoolEntry<Type[]>(new Type[2]
			{
				typeof(Xingguang),
				typeof(AyaNews)
			}, 0.75f)
		};
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}