using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using GamblingMod;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Pun;
using Il2CppRUMBLE.Audio;
using Il2CppRUMBLE.Combat.ShiftStones;
using Il2CppRUMBLE.Economy.Interactables;
using Il2CppRUMBLE.Environment.Howard;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Pools;
using Il2CppRUMBLE.Poses;
using Il2CppRUMBLE.UI;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem;
using Il2CppTMPro;
using MelonLoader;
using RumbleModUI;
using RumbleModdingAPI.RMAPI;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "GamblingMod", "2.2.4", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 6, 6, true)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("GamblingMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+80e37d338d4376dca6e18fa37345b1fd90cbe291")]
[assembly: AssemblyProduct("GamblingMod")]
[assembly: AssemblyTitle("GamblingMod")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace GamblingMod;

public class BlackJack : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass26_0
	{
		public bool continuePressed;

		internal void <GameLoop>b__0()
		{
			continuePressed = true;
		}
	}

	[CompilerGenerated]
	private sealed class <DealerDraw>d__59 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private object <playDrawAnimationCoroutine>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DealerDraw>d__59(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<playDrawAnimationCoroutine>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0146: 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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.dealerHand.Add(<>4__this.DrawCard());
				Log($"Dealer Card {<>4__this.dealerHand.Count}: " + <>4__this.tableInstance.CardString[<>4__this.dealerHand[<>4__this.dealerHand.Count - 1]], (bool)((ModSetting)Main.debugging).SavedValue);
				<playDrawAnimationCoroutine>5__1 = <>4__this.PlayDrawCardAnimation(<>4__this.dealerHand[<>4__this.dealerHand.Count - 1], <>4__this.cardSpots.transform.GetChild(1).GetChild(<>4__this.dealerHand.Count - 1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>2__current = <playDrawAnimationCoroutine>5__1;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DealersTurn>d__58 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private object <revealDealerCardCoroutine>5__1;

		private bool <hasAce>5__2;

		private bool <aceIs11>5__3;

		private int <dealerTotal>5__4;

		private bool <hasSoft17>5__5;

		private object <dealerDrawCorooutine>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DealersTurn>d__58(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<revealDealerCardCoroutine>5__1 = null;
			<dealerDrawCorooutine>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("DealersTurn Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<revealDealerCardCoroutine>5__1 = MelonCoroutines.Start(<>4__this.RevealDealerCard());
				<>2__current = <revealDealerCardCoroutine>5__1;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<hasAce>5__2 = false;
				<aceIs11>5__3 = false;
				<dealerTotal>5__4 = <>4__this.GetDealerHandTotal();
				<hasSoft17>5__5 = (<dealerTotal>5__4 == 17) & <hasAce>5__2 & <aceIs11>5__3;
				break;
			case 2:
				<>1__state = -1;
				<dealerTotal>5__4 = <>4__this.GetDealerHandTotal();
				<hasSoft17>5__5 = (<dealerTotal>5__4 == 17) & <hasAce>5__2 & <aceIs11>5__3;
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<dealerDrawCorooutine>5__6 = null;
				break;
			}
			if ((<dealerTotal>5__4 < 17) | <hasSoft17>5__5)
			{
				<dealerDrawCorooutine>5__6 = MelonCoroutines.Start(<>4__this.DealerDraw());
				<>2__current = <dealerDrawCorooutine>5__6;
				<>1__state = 2;
				return true;
			}
			Log("DealersTurn Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DrawSplit>d__57 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int thisHand;

		public bool recreateOriginal;

		public BlackJack <>4__this;

		private bool <drawFirstSpot>5__1;

		private object <playDrawAnimationCoroutine>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DrawSplit>d__57(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<playDrawAnimationCoroutine>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<drawFirstSpot>5__1 = false;
				if (<>4__this.hand[thisHand][0] == -1)
				{
					<>4__this.hand[thisHand][0] = <>4__this.DrawCard();
					<drawFirstSpot>5__1 = true;
				}
				else
				{
					<>4__this.PlayDrawCardAnimation(<>4__this.hand[thisHand][0], <>4__this.cardSpots.transform.GetChild(0).GetChild(0), <>4__this.cardSpots.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(0f, 0f, 0f), playRotate: false);
				}
				if (<>4__this.hand[thisHand][1] == -1)
				{
					<>4__this.hand[thisHand][1] = <>4__this.DrawCard();
					<drawFirstSpot>5__1 = false;
				}
				else
				{
					<>4__this.PlayDrawCardAnimation(<>4__this.hand[thisHand][1], <>4__this.cardSpots.transform.GetChild(0).GetChild(1), <>4__this.cardSpots.transform.GetChild(0).GetChild(1).position, Quaternion.Euler(0f, 0f, 0f), playRotate: false);
				}
				<playDrawAnimationCoroutine>5__2 = <>4__this.PlayDrawCardAnimation(<>4__this.hand[thisHand][(!<drawFirstSpot>5__1) ? 1 : 0], <>4__this.cardSpots.transform.GetChild(0).GetChild((!<drawFirstSpot>5__1) ? 1 : 0), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>2__current = <playDrawAnimationCoroutine>5__2;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <GameLoop>d__26 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private GameObject <youBrokeAsFuck>5__1;

		private TextMeshPro <endGameTextTMP>5__2;

		private <>c__DisplayClass26_0 <>8__3;

		private List<int> <playerHandTotals>5__4;

		private int <dealerHandTotal>5__5;

		private string <coinLine>5__6;

		private GameObject <endGameText>5__7;

		private TextMeshPro <endGameTextTMP>5__8;

		private GameObject <continueButton>5__9;

		private int <i>5__10;

		private List<GameObject> <handCards>5__11;

		private List<GameObject> <dealerCards>5__12;

		private object <endGameCoroutine0>5__13;

		private object <endGameCoroutine1>5__14;

		private string <cardString0>5__15;

		private string <cardString1>5__16;

		private List<int>.Enumerator <>s__17;

		private int <card>5__18;

		private List<int>.Enumerator <>s__19;

		private int <card>5__20;

		private List<GameObject>.Enumerator <>s__21;

		private GameObject <handCard>5__22;

		private List<GameObject>.Enumerator <>s__23;

		private GameObject <dealerCard>5__24;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GameLoop>d__26(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<youBrokeAsFuck>5__1 = null;
			<endGameTextTMP>5__2 = null;
			<>8__3 = null;
			<playerHandTotals>5__4 = null;
			<coinLine>5__6 = null;
			<endGameText>5__7 = null;
			<endGameTextTMP>5__8 = null;
			<continueButton>5__9 = null;
			<handCards>5__11 = null;
			<dealerCards>5__12 = null;
			<endGameCoroutine0>5__13 = null;
			<endGameCoroutine1>5__14 = null;
			<cardString0>5__15 = null;
			<cardString1>5__16 = null;
			<>s__17 = default(List<int>.Enumerator);
			<>s__19 = default(List<int>.Enumerator);
			<>s__21 = default(List<GameObject>.Enumerator);
			<handCard>5__22 = null;
			<>s__23 = default(List<GameObject>.Enumerator);
			<dealerCard>5__24 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			//IL_0a07: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a11: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			//IL_0c2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c54: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d31: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d3b: Expected O, but got Unknown
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("GameLoop Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.gameLoopRunning = true;
				goto IL_0dab;
			case 1:
				<>1__state = -1;
				goto IL_0111;
			case 2:
				<>1__state = -1;
				<>4__this.gameLoopRunning = false;
				break;
			case 3:
				<>1__state = -1;
				<>4__this.tableInstance.ClearActiveObjects();
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				if (<>4__this.userQuits)
				{
					<>4__this.gameLoopRunning = false;
				}
				if (<>4__this.betAccepted)
				{
					<>8__3 = new <>c__DisplayClass26_0();
					Log("Player Bet Accepted: " + <>4__this.betAmount);
					Main.Payout(-<>4__this.betAmount, 1f, <>4__this.tableInstance);
					<>4__this.betHeldAmount = <>4__this.betAmount;
					<>4__this.coinsGained = 0;
					<>2__current = MelonCoroutines.Start(<>4__this.PlayHands());
					<>1__state = 5;
					return true;
				}
				goto IL_0d99;
			case 5:
				<>1__state = -1;
				<>2__current = MelonCoroutines.Start(<>4__this.DealersTurn());
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<playerHandTotals>5__4 = <>4__this.GetPlayerHandTotal();
				<dealerHandTotal>5__5 = <>4__this.GetDealerHandTotal();
				<i>5__10 = <playerHandTotals>5__4.Count - 1;
				goto IL_0b2f;
			case 7:
				<>1__state = -1;
				<endGameCoroutine0>5__13 = null;
				<endGameCoroutine1>5__14 = null;
				<cardString0>5__15 = "";
				<>s__17 = <>4__this.hand[<i>5__10].GetEnumerator();
				try
				{
					while (<>s__17.MoveNext())
					{
						<card>5__18 = <>s__17.Current;
						<cardString0>5__15 = <cardString0>5__15 + <>4__this.tableInstance.CardString[<card>5__18] + " ";
					}
				}
				finally
				{
					((IDisposable)<>s__17).Dispose();
				}
				<>s__17 = default(List<int>.Enumerator);
				<cardString1>5__16 = "";
				<>s__19 = <>4__this.dealerHand.GetEnumerator();
				try
				{
					while (<>s__19.MoveNext())
					{
						<card>5__20 = <>s__19.Current;
						<cardString1>5__16 = <cardString1>5__16 + <>4__this.tableInstance.CardString[<card>5__20] + " ";
					}
				}
				finally
				{
					((IDisposable)<>s__19).Dispose();
				}
				<>s__19 = default(List<int>.Enumerator);
				Log($"Checking Hand {<i>5__10}: Player {<playerHandTotals>5__4[<i>5__10]} ( {<cardString0>5__15}) vs Dealer {<dealerHandTotal>5__5} ( {<cardString1>5__16})");
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 8;
				return true;
			case 8:
				<>1__state = -1;
				if (<>4__this.has21Immediately)
				{
					Log($"Player Got 21 Immediately! Gained {<>4__this.betAmount * 2} Coins");
					<>4__this.coinsGained += Main.Payout(<>4__this.betAmount, 2f, <>4__this.tableInstance);
					<endGameCoroutine0>5__13 = MelonCoroutines.Start(<>4__this.PlayPlayerWin(<handCards>5__11, <dealerCards>5__12));
				}
				else if (<playerHandTotals>5__4[<i>5__10] > 21)
				{
					Log($"Player Bust, Lost {<>4__this.betAmount} Coins");
					<>4__this.betHeldAmount -= <>4__this.betAmount;
					<>4__this.coinsGained -= <>4__this.betAmount;
					<endGameCoroutine0>5__13 = MelonCoroutines.Start(<>4__this.PlayPlayerBust(<handCards>5__11));
				}
				else if (<playerHandTotals>5__4[<i>5__10] > <dealerHandTotal>5__5 || <dealerHandTotal>5__5 > 21)
				{
					Log($"Player Beat Dealer! Gained {(int)((float)<>4__this.betAmount * 1.5f)} Coins");
					<>4__this.coinsGained += Main.Payout(<>4__this.betAmount, 1.5f, <>4__this.tableInstance);
					<endGameCoroutine0>5__13 = MelonCoroutines.Start(<>4__this.PlayPlayerWin(<handCards>5__11, <dealerCards>5__12));
				}
				else
				{
					Log($"Player Didn't Beat Dealer, Lost {<>4__this.betAmount} Coins");
					<>4__this.betHeldAmount -= <>4__this.betAmount;
					<>4__this.coinsGained -= <>4__this.betAmount;
					<endGameCoroutine0>5__13 = MelonCoroutines.Start(<>4__this.PlayDealerWin(<handCards>5__11, <dealerCards>5__12));
				}
				if (<dealerHandTotal>5__5 > 21)
				{
					<endGameCoroutine1>5__14 = MelonCoroutines.Start(<>4__this.PlayDealerBust(<dealerCards>5__12));
				}
				<>2__current = <endGameCoroutine0>5__13;
				<>1__state = 9;
				return true;
			case 9:
				<>1__state = -1;
				<>2__current = <endGameCoroutine1>5__14;
				<>1__state = 10;
				return true;
			case 10:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 11;
				return true;
			case 11:
				<>1__state = -1;
				<>s__21 = <handCards>5__11.GetEnumerator();
				try
				{
					while (<>s__21.MoveNext())
					{
						<handCard>5__22 = <>s__21.Current;
						Object.Destroy((Object)(object)<handCard>5__22);
						<handCard>5__22 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__21).Dispose();
				}
				<>s__21 = default(List<GameObject>.Enumerator);
				<>s__23 = <dealerCards>5__12.GetEnumerator();
				try
				{
					while (<>s__23.MoveNext())
					{
						<dealerCard>5__24 = <>s__23.Current;
						Object.Destroy((Object)(object)<dealerCard>5__24);
						<dealerCard>5__24 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__23).Dispose();
				}
				<>s__23 = default(List<GameObject>.Enumerator);
				<handCards>5__11 = null;
				<dealerCards>5__12 = null;
				<endGameCoroutine0>5__13 = null;
				<endGameCoroutine1>5__14 = null;
				<cardString0>5__15 = null;
				<cardString1>5__16 = null;
				<i>5__10--;
				goto IL_0b2f;
			case 12:
				{
					<>1__state = -1;
					goto IL_0d4d;
				}
				IL_0111:
				<>4__this.betAmount = 1;
				if (!<>4__this.tableInstance.freePlay && Main.GetPlayerCoinCount() < <>4__this.betAmount)
				{
					<youBrokeAsFuck>5__1 = <>4__this.tableInstance.SpawnText(((Component)<>4__this.activeGamePartsTransform).transform, "Too Few Coins. Try Free Play or" + Environment.NewLine + "Complete More Poses to Earn Coins", new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.65f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
					((Object)<youBrokeAsFuck>5__1).name = "You Broke As Fuck";
					<endGameTextTMP>5__2 = <youBrokeAsFuck>5__1.GetComponent<TextMeshPro>();
					((TMP_Text)<endGameTextTMP>5__2).alignment = (TextAlignmentOptions)514;
					((TMP_Text)<endGameTextTMP>5__2).enableWordWrapping = false;
					<>4__this.continueShuffling = false;
					Log("Not Enough Coins, Exiting BlackJack", (bool)((ModSetting)Main.debugging).SavedValue);
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 2;
					return true;
				}
				<>4__this.tableInstance.ClearActiveObjects();
				<>2__current = MelonCoroutines.Start(<>4__this.RunBetMenu());
				<>1__state = 3;
				return true;
				IL_0d99:
				<>4__this.tableInstance.ClearActiveObjects();
				goto IL_0dab;
				IL_0d4d:
				if (!<>8__3.continuePressed && <>4__this.gameLoopRunning)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 12;
					return true;
				}
				<>8__3 = null;
				<playerHandTotals>5__4 = null;
				<coinLine>5__6 = null;
				<endGameText>5__7 = null;
				<endGameTextTMP>5__8 = null;
				<continueButton>5__9 = null;
				goto IL_0d99;
				IL_0b2f:
				if (<i>5__10 >= 0 && <>4__this.gameLoopRunning)
				{
					<>4__this.ClearVisualCardsFromAHand(isPlayer: true);
					<>4__this.ClearVisualCardsFromAHand(isPlayer: false);
					<handCards>5__11 = <>4__this.SpawnHandCards(<i>5__10);
					<dealerCards>5__12 = <>4__this.SpawnDealerCards();
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 7;
					return true;
				}
				Main.Payout(<>4__this.betHeldAmount, 1f, <>4__this.tableInstance);
				<>8__3.continuePressed = false;
				<coinLine>5__6 = ((<>4__this.coinsGained < 0) ? $"Coins Lost: {-<>4__this.coinsGained}" : $"Coins Gained: {<>4__this.coinsGained}");
				<endGameText>5__7 = <>4__this.tableInstance.SpawnText(((Component)<>4__this.activeGamePartsTransform).transform, <coinLine>5__6, new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.5f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
				((Object)<endGameText>5__7).name = "End Game Text";
				<endGameTextTMP>5__8 = <endGameText>5__7.GetComponent<TextMeshPro>();
				((TMP_Text)<endGameTextTMP>5__8).alignment = (TextAlignmentOptions)514;
				((TMP_Text)<endGameTextTMP>5__8).enableWordWrapping = false;
				<continueButton>5__9 = <>4__this.tableInstance.LoadMenuButton("Continue", new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.96f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), delegate
				{
					<>8__3.continuePressed = true;
				});
				((Object)<continueButton>5__9).name = "Continue";
				goto IL_0d4d;
				IL_0dab:
				if (!<>4__this.gameLoopRunning)
				{
					break;
				}
				if (<>4__this.deck.Count <= 26 * (int)((ModSetting)Main.deckCount).SavedValue)
				{
					<>4__this.RandomizeDeck(continueShuffling: false);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				goto IL_0111;
			}
			Log("GameLoop Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayCardBustCoroutine>d__32 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public BlackJack <>4__this;

		private Vector3 <startingScale>5__1;

		private Vector3 <scalePerTick>5__2;

		private int <i>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayCardBustCoroutine>d__32(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("PlayCardBustCoroutine Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<startingScale>5__1 = card.transform.localScale;
				<scalePerTick>5__2 = <startingScale>5__1 / 50f;
				<i>5__3 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__3++;
				break;
			}
			if (<i>5__3 < 50)
			{
				Transform transform = card.transform;
				transform.localScale -= <scalePerTick>5__2;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			Log("PlayCardBustCoroutine Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayCardReactCoroutine>d__29 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public bool win;

		public bool isPlayer;

		public BlackJack <>4__this;

		private Vector3 <startingPostion>5__1;

		private Vector3 <movePerTick>5__2;

		private int <i>5__3;

		private int <i>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayCardReactCoroutine>d__29(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<startingPostion>5__1 = card.transform.localPosition;
				<movePerTick>5__2 = (isPlayer ? Vector3.back : Vector3.forward) / 50f * (win ? 0.5f : (-0.25f));
				<i>5__3 = 0;
				goto IL_00dc;
			case 1:
				<>1__state = -1;
				<i>5__3++;
				goto IL_00dc;
			case 2:
				{
					<>1__state = -1;
					<i>5__4++;
					break;
				}
				IL_00dc:
				if (<i>5__3 < 25)
				{
					Transform transform = card.transform;
					transform.localPosition += <movePerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<i>5__4 = 0;
				break;
			}
			if (<i>5__4 < 25)
			{
				Transform transform2 = card.transform;
				transform2.localPosition -= <movePerTick>5__2;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			card.transform.localPosition = <startingPostion>5__1;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayDealerBust>d__31 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public List<GameObject> handCards;

		public BlackJack <>4__this;

		private List<object> <cardsReacting>5__1;

		private int <i>5__2;

		private List<object>.Enumerator <>s__3;

		private object <card>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayDealerBust>d__31(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<cardsReacting>5__1 = null;
			<>s__3 = default(List<object>.Enumerator);
			<card>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayDealerBust Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsReacting>5__1 = new List<object>();
					<i>5__2 = 0;
					while (<i>5__2 < handCards.Count)
					{
						<cardsReacting>5__1.Add(MelonCoroutines.Start(<>4__this.PlayCardBustCoroutine(handCards[<i>5__2])));
						<i>5__2++;
					}
					<>s__3 = <cardsReacting>5__1.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<card>5__4 = null;
					break;
				}
				if (<>s__3.MoveNext())
				{
					<card>5__4 = <>s__3.Current;
					<>2__current = <card>5__4;
					<>1__state = 1;
					return true;
				}
				<>m__Finally1();
				<>s__3 = default(List<object>.Enumerator);
				Log("PlayDealerBust Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__3).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayDealerWin>d__33 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public List<GameObject> handCards;

		public List<GameObject> dealerCards;

		public BlackJack <>4__this;

		private List<object> <cardsReacting>5__1;

		private int <i>5__2;

		private int <i>5__3;

		private List<object>.Enumerator <>s__4;

		private object <card>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayDealerWin>d__33(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<cardsReacting>5__1 = null;
			<>s__4 = default(List<object>.Enumerator);
			<card>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayDealerWin Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsReacting>5__1 = new List<object>();
					<i>5__2 = 0;
					while (<i>5__2 < handCards.Count)
					{
						<cardsReacting>5__1.Add(<>4__this.PlayCardReact(handCards[<i>5__2], win: false, isPlayer: true));
						<i>5__2++;
					}
					<i>5__3 = 0;
					while (<i>5__3 < dealerCards.Count)
					{
						<cardsReacting>5__1.Add(<>4__this.PlayCardReact(dealerCards[<i>5__3], win: true, isPlayer: false));
						<i>5__3++;
					}
					<>s__4 = <cardsReacting>5__1.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<card>5__5 = null;
					break;
				}
				if (<>s__4.MoveNext())
				{
					<card>5__5 = <>s__4.Current;
					<>2__current = <card>5__5;
					<>1__state = 1;
					return true;
				}
				<>m__Finally1();
				<>s__4 = default(List<object>.Enumerator);
				Log("PlayDealerWin Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__4).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayDrawAnimation>d__43 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public int ticks;

		public bool playRotate;

		public BlackJack <>4__this;

		private Vector3 <distancePerTick>5__1;

		private float <rotationPerTick>5__2;

		private float <currentRotationX>5__3;

		private float <currentRotationY>5__4;

		private float <currentRotationZ>5__5;

		private int <i>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayDrawAnimation>d__43(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0049: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				Log("PlayDrawAnimation Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<distancePerTick>5__1 = card.transform.localPosition / (float)ticks;
				<rotationPerTick>5__2 = 180f / (float)ticks;
				Quaternion localRotation = card.transform.localRotation;
				<currentRotationX>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.x;
				localRotation = card.transform.localRotation;
				<currentRotationY>5__4 = ((Quaternion)(ref localRotation)).eulerAngles.y;
				localRotation = card.transform.localRotation;
				<currentRotationZ>5__5 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				<i>5__6 = 0;
				break;
			}
			case 1:
				<>1__state = -1;
				<i>5__6++;
				break;
			}
			if (<i>5__6 < 25)
			{
				Transform transform = card.transform;
				transform.localPosition -= <distancePerTick>5__1;
				if (playRotate)
				{
					<currentRotationX>5__3 -= <rotationPerTick>5__2;
					card.transform.localRotation = Quaternion.Euler(<currentRotationX>5__3, <currentRotationY>5__4, <currentRotationZ>5__5);
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			Log("PlayDrawAnimation Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayHands>d__40 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private int <thisHand>5__1;

		private object <playDrawAnimationCoroutine>5__2;

		private object <playDrawAnimationCoroutine2>5__3;

		private object <playDrawAnimationCoroutine3>5__4;

		private object <playDrawAnimationCoroutine4>5__5;

		private object <optionsMenuCoroutine>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayHands>d__40(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<playDrawAnimationCoroutine>5__2 = null;
			<playDrawAnimationCoroutine2>5__3 = null;
			<playDrawAnimationCoroutine3>5__4 = null;
			<playDrawAnimationCoroutine4>5__5 = null;
			<optionsMenuCoroutine>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("PlayHands Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.hand = new List<List<int>>();
				<>4__this.dealerHand = new List<int>();
				<>4__this.has21Immediately = false;
				<>4__this.SetupCardSpots();
				<thisHand>5__1 = <>4__this.hand.Count;
				<>4__this.hand.Add(new List<int>());
				<>4__this.hand[<>4__this.hand.Count - 1].Add(<>4__this.DrawCard());
				Log("Player Card 1: " + <>4__this.tableInstance.CardString[<>4__this.hand[<>4__this.hand.Count - 1][0]], (bool)((ModSetting)Main.debugging).SavedValue);
				<playDrawAnimationCoroutine>5__2 = <>4__this.PlayDrawCardAnimation(<>4__this.hand[<>4__this.hand.Count - 1][0], <>4__this.cardSpots.transform.GetChild(0).GetChild(0), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>2__current = <playDrawAnimationCoroutine>5__2;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.dealerHand.Add(<>4__this.DrawCard());
				Log("Dealer Card 1: " + <>4__this.tableInstance.CardString[<>4__this.dealerHand[0]], (bool)((ModSetting)Main.debugging).SavedValue);
				<playDrawAnimationCoroutine2>5__3 = <>4__this.PlayDrawCardAnimation(<>4__this.dealerHand[0], <>4__this.cardSpots.transform.GetChild(1).GetChild(0), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>2__current = <playDrawAnimationCoroutine2>5__3;
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.hand[<>4__this.hand.Count - 1].Add(<>4__this.DrawCard());
				Log("Player Card 2: " + <>4__this.tableInstance.CardString[<>4__this.hand[<>4__this.hand.Count - 1][1]], (bool)((ModSetting)Main.debugging).SavedValue);
				<playDrawAnimationCoroutine3>5__4 = <>4__this.PlayDrawCardAnimation(<>4__this.hand[<>4__this.hand.Count - 1][1], <>4__this.cardSpots.transform.GetChild(0).GetChild(1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>2__current = <playDrawAnimationCoroutine3>5__4;
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.dealerHand.Add(<>4__this.DrawCard());
				Log("Dealer Card 2: -_-", (bool)((ModSetting)Main.debugging).SavedValue);
				<playDrawAnimationCoroutine4>5__5 = <>4__this.PlayDrawCardAnimation(52, <>4__this.cardSpots.transform.GetChild(1).GetChild(1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f), playRotate: false);
				<>2__current = <playDrawAnimationCoroutine4>5__5;
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				if (<>4__this.GetCardsTotal(<>4__this.hand[<thisHand>5__1]) == 21)
				{
					<>4__this.has21Immediately = true;
					break;
				}
				<optionsMenuCoroutine>5__6 = MelonCoroutines.Start(<>4__this.RunOptionsMenu(<thisHand>5__1));
				<>2__current = <optionsMenuCoroutine>5__6;
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<optionsMenuCoroutine>5__6 = null;
				break;
			}
			Log("PlayHands Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayPlayerBust>d__30 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public List<GameObject> handCards;

		public BlackJack <>4__this;

		private List<object> <cardsReacting>5__1;

		private int <i>5__2;

		private List<object>.Enumerator <>s__3;

		private object <card>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayPlayerBust>d__30(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<cardsReacting>5__1 = null;
			<>s__3 = default(List<object>.Enumerator);
			<card>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayPlayerBust Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsReacting>5__1 = new List<object>();
					<i>5__2 = 0;
					while (<i>5__2 < handCards.Count)
					{
						<cardsReacting>5__1.Add(MelonCoroutines.Start(<>4__this.PlayCardBustCoroutine(handCards[<i>5__2])));
						<i>5__2++;
					}
					<>s__3 = <cardsReacting>5__1.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<card>5__4 = null;
					break;
				}
				if (<>s__3.MoveNext())
				{
					<card>5__4 = <>s__3.Current;
					<>2__current = <card>5__4;
					<>1__state = 1;
					return true;
				}
				<>m__Finally1();
				<>s__3 = default(List<object>.Enumerator);
				Log("PlayPlayerBust Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__3).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayPlayerWin>d__27 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public List<GameObject> handCards;

		public List<GameObject> dealerCards;

		public BlackJack <>4__this;

		private List<object> <cardsReacting>5__1;

		private int <i>5__2;

		private int <i>5__3;

		private List<object>.Enumerator <>s__4;

		private object <card>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayPlayerWin>d__27(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 1)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<cardsReacting>5__1 = null;
			<>s__4 = default(List<object>.Enumerator);
			<card>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayPlayerWin Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsReacting>5__1 = new List<object>();
					<i>5__2 = 0;
					while (<i>5__2 < handCards.Count)
					{
						<cardsReacting>5__1.Add(<>4__this.PlayCardReact(handCards[<i>5__2], win: true, isPlayer: true));
						<i>5__2++;
					}
					<i>5__3 = 0;
					while (<i>5__3 < dealerCards.Count)
					{
						<cardsReacting>5__1.Add(<>4__this.PlayCardReact(dealerCards[<i>5__3], win: false, isPlayer: false));
						<i>5__3++;
					}
					<>s__4 = <cardsReacting>5__1.GetEnumerator();
					<>1__state = -3;
					break;
				case 1:
					<>1__state = -3;
					<card>5__5 = null;
					break;
				}
				if (<>s__4.MoveNext())
				{
					<card>5__5 = <>s__4.Current;
					<>2__current = <card>5__5;
					<>1__state = 1;
					return true;
				}
				<>m__Finally1();
				<>s__4 = default(List<object>.Enumerator);
				Log("PlayPlayerWin Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__4).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RevealDealerCard>d__36 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private float <rotationPerTick>5__1;

		private Transform <dealerCard>5__2;

		private GameObject <newCard>5__3;

		private float <currentRotationX>5__4;

		private float <currentRotationY>5__5;

		private float <currentRotationZ>5__6;

		private int <i>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RevealDealerCard>d__36(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<dealerCard>5__2 = null;
			<newCard>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: 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_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				Log("RevealDealerCard Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<rotationPerTick>5__1 = 7.2f;
				<dealerCard>5__2 = <>4__this.cardSpots.transform.GetChild(1).GetChild(1).GetChild(0);
				<newCard>5__3 = Object.Instantiate<GameObject>(((Component)<>4__this.tableInstance.storedDeckOfCards.transform.GetChild(<>4__this.dealerHand[1])).gameObject);
				<newCard>5__3.transform.SetParent(((Component)<dealerCard>5__2).transform.parent);
				<newCard>5__3.transform.position = ((Component)<dealerCard>5__2).transform.position;
				<newCard>5__3.transform.rotation = ((Component)<dealerCard>5__2).transform.rotation;
				<newCard>5__3.transform.localScale = ((Component)<dealerCard>5__2).transform.localScale;
				Quaternion localRotation = <newCard>5__3.transform.localRotation;
				<currentRotationX>5__4 = ((Quaternion)(ref localRotation)).eulerAngles.x;
				localRotation = <newCard>5__3.transform.localRotation;
				<currentRotationY>5__5 = ((Quaternion)(ref localRotation)).eulerAngles.y;
				localRotation = <newCard>5__3.transform.localRotation;
				<currentRotationZ>5__6 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				Object.Destroy((Object)(object)((Component)<dealerCard>5__2).gameObject);
				<i>5__7 = 0;
				break;
			}
			case 1:
				<>1__state = -1;
				<i>5__7++;
				break;
			}
			if (<i>5__7 < 25)
			{
				<currentRotationX>5__4 -= <rotationPerTick>5__1;
				<newCard>5__3.transform.localRotation = Quaternion.Euler(<currentRotationX>5__4, <currentRotationY>5__5, <currentRotationZ>5__6);
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			Log("Completed Rotation", (bool)((ModSetting)Main.debugging).SavedValue);
			Log("RevealDealerCard Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <Run>d__22 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <Run>d__22(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("Run Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.SetupStart();
				<>4__this.gameLoopCoroutine = MelonCoroutines.Start(<>4__this.GameLoop());
				<>2__current = <>4__this.gameLoopCoroutine;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Log("Run Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunBetMenu>d__44 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public BlackJack <>4__this;

		private GameObject <betsMenu>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunBetMenu>d__44(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<betsMenu>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("RunBetMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.betAmount = 1;
				<betsMenu>5__1 = <>4__this.SpawnBetsMenu();
				Log("Spawned Bets Menu, Waiting for Accepted Bet", (bool)((ModSetting)Main.debugging).SavedValue);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!<>4__this.betAccepted && !<>4__this.userQuits)
			{
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			if (<>4__this.betAccepted)
			{
				<>4__this.betHeldAmount = <>4__this.betAmount;
				Log("Bet Accepted, Bet: " + <>4__this.betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			}
			Log("RunBetMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunOptionsMenu>d__55 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int thisHand;

		public BlackJack <>4__this;

		private GameObject <optionsMenu>5__1;

		private object <playDrawAnimationCoroutine>5__2;

		private object <optionsInOptionsMenuCoroutine>5__3;

		private List<int> <secondHand>5__4;

		private string <cardsString>5__5;

		private object <drawSplitCoroutine>5__6;

		private int <secondHandSpot>5__7;

		private List<int>.Enumerator <>s__8;

		private int <i>5__9;

		private List<int>.Enumerator <>s__10;

		private int <i>5__11;

		private object <runOptionsMenuCoroutine>5__12;

		private object <runOptionsMenuCoroutine>5__13;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunOptionsMenu>d__55(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<optionsMenu>5__1 = null;
			<playDrawAnimationCoroutine>5__2 = null;
			<optionsInOptionsMenuCoroutine>5__3 = null;
			<secondHand>5__4 = null;
			<cardsString>5__5 = null;
			<drawSplitCoroutine>5__6 = null;
			<>s__8 = default(List<int>.Enumerator);
			<>s__10 = default(List<int>.Enumerator);
			<runOptionsMenuCoroutine>5__12 = null;
			<runOptionsMenuCoroutine>5__13 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0839: Expected O, but got Unknown
			//IL_0967: Unknown result type (might be due to invalid IL or missing references)
			//IL_0971: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("RunOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<optionsMenu>5__1 = <>4__this.SpawnOptionsMenu(thisHand);
				Log("Spawned Options Menu, Waiting for Selection", (bool)((ModSetting)Main.debugging).SavedValue);
				goto IL_00da;
			case 1:
				<>1__state = -1;
				goto IL_00da;
			case 2:
				<>1__state = -1;
				if (<>4__this.GetCardsTotal(<>4__this.hand[thisHand]) < 21)
				{
					<optionsInOptionsMenuCoroutine>5__3 = MelonCoroutines.Start(<>4__this.RunOptionsMenu(thisHand));
					<>2__current = <optionsInOptionsMenuCoroutine>5__3;
					<>1__state = 3;
					return true;
				}
				if (<>4__this.GetCardsTotal(<>4__this.hand[thisHand]) > 21)
				{
					Log("Player Bust, Total: " + <>4__this.GetCardsTotal(<>4__this.hand[thisHand]), (bool)((ModSetting)Main.debugging).SavedValue);
				}
				else
				{
					Log("Player Got 21, Stopping Hand", (bool)((ModSetting)Main.debugging).SavedValue);
				}
				goto IL_03fc;
			case 3:
				<>1__state = -1;
				<optionsInOptionsMenuCoroutine>5__3 = null;
				goto IL_03fc;
			case 4:
				<>1__state = -1;
				if (<>4__this.GetCardsTotal(<>4__this.hand[thisHand]) < 21)
				{
					<runOptionsMenuCoroutine>5__12 = MelonCoroutines.Start(<>4__this.RunOptionsMenu(thisHand));
					<>2__current = <runOptionsMenuCoroutine>5__12;
					<>1__state = 5;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 6;
				return true;
			case 5:
				<>1__state = -1;
				<runOptionsMenuCoroutine>5__12 = null;
				goto IL_0849;
			case 6:
				<>1__state = -1;
				goto IL_0849;
			case 7:
				<>1__state = -1;
				if (<>4__this.GetCardsTotal(<>4__this.hand[<secondHandSpot>5__7]) <= 21)
				{
					<runOptionsMenuCoroutine>5__13 = MelonCoroutines.Start(<>4__this.RunOptionsMenu(<secondHandSpot>5__7));
					<>2__current = <runOptionsMenuCoroutine>5__13;
					<>1__state = 8;
					return true;
				}
				goto IL_0961;
			case 8:
				<>1__state = -1;
				<runOptionsMenuCoroutine>5__13 = null;
				goto IL_0961;
			case 9:
				{
					<>1__state = -1;
					<secondHand>5__4 = null;
					<cardsString>5__5 = null;
					<drawSplitCoroutine>5__6 = null;
					break;
				}
				IL_00da:
				if (!<>4__this.pressedStay && !<>4__this.pressedHit && !<>4__this.pressedSplit)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				Object.Destroy((Object)(object)<optionsMenu>5__1);
				if (<>4__this.pressedHit)
				{
					Log("Pressed Hit", (bool)((ModSetting)Main.debugging).SavedValue);
					<>4__this.hand[thisHand].Add(<>4__this.DrawCard());
					Log($"Player Card {<>4__this.hand[thisHand].Count}: {<>4__this.tableInstance.CardString[<>4__this.hand[thisHand][<>4__this.hand[thisHand].Count - 1]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					<playDrawAnimationCoroutine>5__2 = <>4__this.PlayDrawCardAnimation(<>4__this.hand[thisHand][<>4__this.hand[thisHand].Count - 1], <>4__this.cardSpots.transform.GetChild(0).GetChild(<>4__this.hand[thisHand].Count - 1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
					<>2__current = <playDrawAnimationCoroutine>5__2;
					<>1__state = 2;
					return true;
				}
				if (<>4__this.pressedStay)
				{
					Log("Pressed Stay", (bool)((ModSetting)Main.debugging).SavedValue);
				}
				else
				{
					if (!<>4__this.pressedSplit)
					{
						break;
					}
					Log("Pressed Split", (bool)((ModSetting)Main.debugging).SavedValue);
					Log("Player Split Bet Accepted: " + <>4__this.betAmount);
					Main.Payout(-<>4__this.betAmount, 1f, <>4__this.tableInstance);
					<>4__this.betHeldAmount += <>4__this.betAmount;
					<secondHand>5__4 = new List<int>();
					<secondHand>5__4.Add(-1);
					<secondHand>5__4.Add(<>4__this.hand[thisHand][1]);
					<>4__this.hand[thisHand][1] = -1;
					<cardsString>5__5 = "";
					<>s__8 = <>4__this.hand[thisHand].GetEnumerator();
					try
					{
						while (<>s__8.MoveNext())
						{
							<i>5__9 = <>s__8.Current;
							if (<i>5__9 != -1)
							{
								<cardsString>5__5 += <>4__this.tableInstance.CardString[<i>5__9];
							}
							else
							{
								<cardsString>5__5 += "-1";
							}
							<cardsString>5__5 += " ";
						}
					}
					finally
					{
						((IDisposable)<>s__8).Dispose();
					}
					<>s__8 = default(List<int>.Enumerator);
					Log($"Hand {thisHand}: {<cardsString>5__5}", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsString>5__5 = "";
					<>s__10 = <secondHand>5__4.GetEnumerator();
					try
					{
						while (<>s__10.MoveNext())
						{
							<i>5__11 = <>s__10.Current;
							if (<i>5__11 != -1)
							{
								<cardsString>5__5 += <>4__this.tableInstance.CardString[<i>5__11];
							}
							else
							{
								<cardsString>5__5 += "-1";
							}
							<cardsString>5__5 += " ";
						}
					}
					finally
					{
						((IDisposable)<>s__10).Dispose();
					}
					<>s__10 = default(List<int>.Enumerator);
					Log("Next Hand: " + <cardsString>5__5, (bool)((ModSetting)Main.debugging).SavedValue);
					<>4__this.ClearVisualCardsFromAHand(isPlayer: true);
					Log("Playing First Hand", (bool)((ModSetting)Main.debugging).SavedValue);
					<drawSplitCoroutine>5__6 = MelonCoroutines.Start(<>4__this.DrawSplit(thisHand));
					<>2__current = <drawSplitCoroutine>5__6;
					<>1__state = 4;
					return true;
				}
				break;
				IL_0961:
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 9;
				return true;
				IL_0849:
				Log("Setting Up For Next Hand", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.ClearVisualCardsFromAHand(isPlayer: true);
				<>4__this.hand.Add(<secondHand>5__4);
				<secondHandSpot>5__7 = <>4__this.hand.Count - 1;
				Log("Playing Next Hand", (bool)((ModSetting)Main.debugging).SavedValue);
				<drawSplitCoroutine>5__6 = MelonCoroutines.Start(<>4__this.DrawSplit(<secondHandSpot>5__7, recreateOriginal: true));
				<>2__current = <drawSplitCoroutine>5__6;
				<>1__state = 7;
				return true;
				IL_03fc:
				<playDrawAnimationCoroutine>5__2 = null;
				break;
			}
			Log("RunOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ShufflingCard>d__49 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public object spinCoroutine;

		public BlackJack <>4__this;

		private Transform <cardsParent>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ShufflingCard>d__49(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<cardsParent>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<cardsParent>5__1 = <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).GetChild(0);
				<>2__current = spinCoroutine;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				break;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				break;
			}
			if (<>4__this.continueShuffling && (Object)(object)<>4__this.tableInstance.blackJackInstance != (Object)null)
			{
				spinCoroutine = MelonCoroutines.Start(<>4__this.tableInstance.SpinCard(card));
				<>2__current = spinCoroutine;
				<>1__state = 2;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private int betAmount = 1;

	private int betHeldAmount = 0;

	private bool gameLoopRunning = false;

	private TextMeshPro betTextComponent = null;

	private GameObject storedBetsMenu = null;

	private GameObject storedOptionsMenu = null;

	private bool betAccepted = false;

	private bool userQuits = false;

	private List<int> deck;

	private List<int> dealerHand;

	private List<List<int>> hand;

	public object gameLoopCoroutine = null;

	private Transform storedGamePartsTransform = null;

	private Transform activeGamePartsTransform = null;

	private Table tableInstance;

	private GameObject cardSpots = null;

	private bool has21Immediately = false;

	private int coinsGained = 0;

	private bool continueShuffling = true;

	private bool pressedStay;

	private bool pressedHit;

	private bool pressedSplit;

	public BlackJack(Table tableInstance)
	{
		this.tableInstance = tableInstance;
	}

	public static void Log(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Table.Log("BlackJack - " + msg, sendMsg);
		}
	}

	public static void Warn(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Table.Warn("BlackJack - " + msg, sendMsg);
		}
	}

	public static void Error(string msg)
	{
		Table.Error("BlackJack - " + msg);
	}

	public void ShowSplash()
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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)
		storedGamePartsTransform = ((Component)tableInstance).transform.GetChild(1);
		activeGamePartsTransform = ((Component)tableInstance).transform.GetChild(2);
		GameObject val = new GameObject("SplashScreen");
		val.transform.SetParent(activeGamePartsTransform);
		val.transform.localPosition = new Vector3(0f, 0.9454f, 0f);
		val.transform.localRotation = Quaternion.identity;
		val.transform.localScale = Vector3.one;
		GameObject val2 = tableInstance.SpawnText(val.transform, "BlackJack", new Vector3(0f, 0f, 0.4f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1.25f, 1.25f, 1.25f));
		TextMeshPro component = val2.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
	}

	[IteratorStateMachine(typeof(<Run>d__22))]
	public IEnumerator Run()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <Run>d__22(0)
		{
			<>4__this = this
		};
	}

	private void SetupStart()
	{
		Log("SetupStart Running", (bool)((ModSetting)Main.debugging).SavedValue);
		gameLoopRunning = false;
		RandomizeDeck();
		SetupBetMenu();
		SetupOptionsMenu();
		Log("SetupStart Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void SetupCardSpots()
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		cardSpots = Object.Instantiate<GameObject>(((Component)storedGamePartsTransform.GetChild(1)).gameObject);
		((Object)cardSpots).name = "CardSpots";
		cardSpots.transform.SetParent(activeGamePartsTransform);
		cardSpots.transform.localPosition = Vector3.zero;
		cardSpots.transform.localRotation = Quaternion.identity;
		cardSpots.transform.localScale = Vector3.one;
	}

	[IteratorStateMachine(typeof(<GameLoop>d__26))]
	private IEnumerator GameLoop()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GameLoop>d__26(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<PlayPlayerWin>d__27))]
	private IEnumerator PlayPlayerWin(List<GameObject> handCards, List<GameObject> dealerCards)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayPlayerWin>d__27(0)
		{
			<>4__this = this,
			handCards = handCards,
			dealerCards = dealerCards
		};
	}

	private object PlayCardReact(GameObject card, bool win, bool isPlayer)
	{
		return MelonCoroutines.Start(PlayCardReactCoroutine(card, win, isPlayer));
	}

	[IteratorStateMachine(typeof(<PlayCardReactCoroutine>d__29))]
	private IEnumerator PlayCardReactCoroutine(GameObject card, bool win, bool isPlayer)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayCardReactCoroutine>d__29(0)
		{
			<>4__this = this,
			card = card,
			win = win,
			isPlayer = isPlayer
		};
	}

	[IteratorStateMachine(typeof(<PlayPlayerBust>d__30))]
	private IEnumerator PlayPlayerBust(List<GameObject> handCards)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayPlayerBust>d__30(0)
		{
			<>4__this = this,
			handCards = handCards
		};
	}

	[IteratorStateMachine(typeof(<PlayDealerBust>d__31))]
	private IEnumerator PlayDealerBust(List<GameObject> handCards)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayDealerBust>d__31(0)
		{
			<>4__this = this,
			handCards = handCards
		};
	}

	[IteratorStateMachine(typeof(<PlayCardBustCoroutine>d__32))]
	private IEnumerator PlayCardBustCoroutine(GameObject card)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayCardBustCoroutine>d__32(0)
		{
			<>4__this = this,
			card = card
		};
	}

	[IteratorStateMachine(typeof(<PlayDealerWin>d__33))]
	private IEnumerator PlayDealerWin(List<GameObject> handCards, List<GameObject> dealerCards)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayDealerWin>d__33(0)
		{
			<>4__this = this,
			handCards = handCards,
			dealerCards = dealerCards
		};
	}

	private List<GameObject> SpawnHandCards(int thisHand)
	{
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		List<GameObject> list = new List<GameObject>();
		for (int i = 0; i < hand[thisHand].Count; i++)
		{
			GameObject val = Object.Instantiate<GameObject>(((Component)tableInstance.storedDeckOfCards.transform.GetChild(hand[thisHand][i])).gameObject);
			val.transform.SetParent(cardSpots.transform.GetChild(0).GetChild(i));
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			list.Add(val);
		}
		return list;
	}

	private List<GameObject> SpawnDealerCards()
	{
		//IL_0061: 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)
		List<GameObject> list = new List<GameObject>();
		for (int i = 0; i < dealerHand.Count; i++)
		{
			GameObject val = Object.Instantiate<GameObject>(((Component)tableInstance.storedDeckOfCards.transform.GetChild(dealerHand[i])).gameObject);
			val.transform.SetParent(cardSpots.transform.GetChild(1).GetChild(i));
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			list.Add(val);
		}
		return list;
	}

	[IteratorStateMachine(typeof(<RevealDealerCard>d__36))]
	private IEnumerator RevealDealerCard()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RevealDealerCard>d__36(0)
		{
			<>4__this = this
		};
	}

	private List<int> GetPlayerHandTotal()
	{
		Log("GetPlayerHandTotal Started", (bool)((ModSetting)Main.debugging).SavedValue);
		List<int> list = new List<int>();
		int num = 0;
		bool flag = false;
		foreach (List<int> item in hand)
		{
			foreach (int item2 in item)
			{
				int num2;
				for (num2 = item2; num2 >= 13; num2 -= 13)
				{
				}
				num2 = Math.Clamp(num2 + 1, 1, 10);
				if (num2 == 1)
				{
					flag = true;
				}
				num += num2;
			}
			if (flag && num <= 11)
			{
				num += 10;
			}
			list.Add(num);
			num = 0;
		}
		Log("GetPlayerHandTotal Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return list;
	}

	private int GetDealerHandTotal()
	{
		Log("GetDealerHandTotal Started", (bool)((ModSetting)Main.debugging).SavedValue);
		int num = 0;
		bool flag = false;
		foreach (int item in dealerHand)
		{
			int num2;
			for (num2 = item; num2 >= 13; num2 -= 13)
			{
			}
			num2 = Math.Clamp(num2 + 1, 1, 10);
			if (num2 == 1)
			{
				flag = true;
			}
			num += num2;
		}
		if (flag && num <= 11)
		{
			num += 10;
		}
		Log("GetDealerHandTotal Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return num;
	}

	private int GetCardsTotal(List<int> cards)
	{
		Log("GetCardsTotal Started", (bool)((ModSetting)Main.debugging).SavedValue);
		int num = 0;
		bool flag = false;
		foreach (int card in cards)
		{
			int num2;
			for (num2 = card; num2 >= 13; num2 -= 13)
			{
			}
			num2 = Math.Clamp(num2 + 1, 1, 10);
			if (num2 == 1)
			{
				flag = true;
			}
			num += num2;
			Log($"Card {tableInstance.CardString[card]}: {num2}", (bool)((ModSetting)Main.debugging).SavedValue);
		}
		if (flag && num <= 11)
		{
			num += 10;
			Log("Ace able to be 11", (bool)((ModSetting)Main.debugging).SavedValue);
		}
		Log("GetCardsTotal Completed: " + num, (bool)((ModSetting)Main.debugging).SavedValue);
		return num;
	}

	[IteratorStateMachine(typeof(<PlayHands>d__40))]
	private IEnumerator PlayHands()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayHands>d__40(0)
		{
			<>4__this = this
		};
	}

	private object PlayDrawCardAnimation(int CardToDraw, Transform parent, Vector3 position, Quaternion localRotation, bool playRotate = true)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		Log("PlayDrawCardAnimation Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(((Component)tableInstance.storedDeckOfCards.transform.GetChild(CardToDraw)).gameObject);
		val.transform.SetParent(parent);
		val.transform.position = position;
		val.transform.localRotation = localRotation;
		Log("PlayDrawCardAnimation Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return MelonCoroutines.Start(PlayDrawAnimation(val, 25, playRotate));
	}

	private int DrawCard()
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if (deck.Count == 0)
		{
			RandomizeDeck();
		}
		int result = deck[0];
		deck.RemoveAt(0);
		tableInstance.dealerDeck.transform.localScale = new Vector3(1f, (float)deck.Count / 52f, 1f);
		return result;
	}

	[IteratorStateMachine(typeof(<PlayDrawAnimation>d__43))]
	private IEnumerator PlayDrawAnimation(GameObject card, int ticks = 25, bool playRotate = true)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayDrawAnimation>d__43(0)
		{
			<>4__this = this,
			card = card,
			ticks = ticks,
			playRotate = playRotate
		};
	}

	[IteratorStateMachine(typeof(<RunBetMenu>d__44))]
	private IEnumerator RunBetMenu()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunBetMenu>d__44(0)
		{
			<>4__this = this
		};
	}

	private GameObject SpawnBetsMenu()
	{
		//IL_005a: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		Log("SpawnBetsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(storedBetsMenu);
		val.transform.SetParent(activeGamePartsTransform);
		val.transform.localPosition = new Vector3(0f, tableInstance.TABLEHEIGHT - 0.052f, 0f);
		val.transform.localRotation = Quaternion.identity;
		val.transform.localScale = Vector3.one;
		betTextComponent = ((Component)val.transform.GetChild(1)).GetComponent<TextMeshPro>();
		UpdateBetAmountText();
		((Component)val.transform.GetChild(2).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Down Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (1 < betAmount)
			{
				betAmount--;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(3).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Up Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (Main.GetPlayerCoinCount() >= betAmount + 1)
			{
				betAmount++;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(4).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Down Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (10 < betAmount)
			{
				betAmount -= 10;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(5).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Up Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (Main.GetPlayerCoinCount() >= betAmount + 10)
			{
				betAmount += 10;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(6).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Accepted: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			betAccepted = true;
			continueShuffling = false;
		}));
		((Component)val.transform.GetChild(7).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("User Quit During Betting", (bool)((ModSetting)Main.debugging).SavedValue);
			userQuits = true;
			continueShuffling = false;
		}));
		((Component)val.transform.GetChild(8).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Min Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			betAmount = 1;
			Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			UpdateBetAmountText();
		}));
		((Component)val.transform.GetChild(9).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Max Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			betAmount = Main.GetPlayerCoinCount();
			Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			UpdateBetAmountText();
		}));
		val.transform.GetChild(9).GetChild(2).localPosition = new Vector3(0f, 0f, -0.25f);
		betAccepted = false;
		userQuits = false;
		Log("SpawnBetsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	private void RandomizeDeck(bool continueShuffling = true)
	{
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		Log("RandomizeDeck Running", (bool)((ModSetting)Main.debugging).SavedValue);
		object[] shufflings = tableInstance.ShuffleDealerDeck();
		if (continueShuffling)
		{
			ContinueShufflings(shufflings);
		}
		deck = new List<int>();
		List<int> list = new List<int>();
		int num = 0;
		for (int i = 0; i < 52 * (int)((ModSetting)Main.deckCount).SavedValue; i++)
		{
			deck.Add(num);
			num++;
			if (num == 52)
			{
				num = 0;
			}
		}
		Log("Deck Setup Done", (bool)((ModSetting)Main.debugging).SavedValue);
		tableInstance.dealerDeck.transform.localScale = new Vector3(1f, (float)deck.Count / 52f, 1f);
		list.Clear();
		while (deck.Count > 0)
		{
			int index = tableInstance.random.Next(deck.Count);
			list.Add(deck[index]);
			deck.RemoveAt(index);
		}
		deck.AddRange(list);
		Log("RandomizeDeck Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void ContinueShufflings(object[] shufflings)
	{
		continueShuffling = true;
		Transform child = tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).GetChild(0);
		for (int i = 0; i < shufflings.Length; i++)
		{
			MelonCoroutines.Start(ShufflingCard(((Component)((Component)child).transform.GetChild(i)).gameObject, shufflings[i]));
		}
	}

	[IteratorStateMachine(typeof(<ShufflingCard>d__49))]
	private IEnumerator ShufflingCard(GameObject card, object spinCoroutine)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ShufflingCard>d__49(0)
		{
			<>4__this = this,
			card = card,
			spinCoroutine = spinCoroutine
		};
	}

	private void SetupBetMenu()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0276: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_032a: Unknown result type (might be due to invalid IL or missing references)
		//IL_033e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0352: Unknown result type (might be due to invalid IL or missing references)
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_0398: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_03de: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0406: Unknown result type (might be due to invalid IL or missing references)
		//IL_0438: Unknown result type (might be due to invalid IL or missing references)
		//IL_044c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0460: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupBetMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if ((Object)(object)storedBetsMenu != (Object)null)
		{
			Object.Destroy((Object)(object)storedBetsMenu);
		}
		storedBetsMenu = new GameObject("BetsMenu");
		storedBetsMenu.transform.SetParent(storedGamePartsTransform);
		storedBetsMenu.transform.localPosition = Vector3.zero;
		storedBetsMenu.transform.localRotation = Quaternion.identity;
		storedBetsMenu.transform.localScale = Vector3.one;
		GameObject val = tableInstance.SpawnText(storedBetsMenu.transform, "How Much To Bet?", new Vector3(0f, 0f, 0.35f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1.25f, 1.25f, 1.25f));
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
		GameObject val2 = tableInstance.SpawnText(storedBetsMenu.transform, "BetText", new Vector3(0f, 0f, 0.5f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
		TextMeshPro component2 = val2.GetComponent<TextMeshPro>();
		((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component2).enableWordWrapping = false;
		betTextComponent = val2.GetComponent<TextMeshPro>();
		UpdateBetAmountText();
		GameObject val3 = tableInstance.SpawnButton(storedBetsMenu.transform, "-1", new Vector3(0.15f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val4 = tableInstance.SpawnButton(storedBetsMenu.transform, "+1", new Vector3(-0.15f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val5 = tableInstance.SpawnButton(storedBetsMenu.transform, "-10", new Vector3(0.325f, 0f, 0.85f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val6 = tableInstance.SpawnButton(storedBetsMenu.transform, "+10", new Vector3(-0.325f, 0f, 0.85f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val7 = tableInstance.SpawnButton(storedBetsMenu.transform, "Accept", new Vector3(0f, 0f, 0.75f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val8 = tableInstance.SpawnButton(storedBetsMenu.transform, "Exit", new Vector3(0.75f, 0f, 0.25f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val9 = tableInstance.SpawnButton(storedBetsMenu.transform, "Min", new Vector3(0.5f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val10 = tableInstance.SpawnButton(storedBetsMenu.transform, "Max", new Vector3(-0.5f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		Log("SetupBetMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private GameObject SpawnOptionsMenu(int thisHand)
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: 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_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		Log("SpawnOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		pressedStay = false;
		pressedHit = false;
		pressedSplit = false;
		GameObject val = Object.Instantiate<GameObject>(storedOptionsMenu);
		val.transform.SetParent(activeGamePartsTransform);
		val.transform.localPosition = new Vector3(0f, tableInstance.TABLEHEIGHT - 0.052f, 0f);
		val.transform.localRotation = Quaternion.identity;
		val.transform.localScale = Vector3.one;
		((Component)val.transform.GetChild(0).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Stay Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			pressedStay = true;
		}));
		((Component)val.transform.GetChild(1).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Hit Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			pressedHit = true;
		}));
		val.transform.GetChild(1).GetChild(2).localPosition = new Vector3(0f, 0f, -0.25f);
		if (SplitIsPossible(hand[thisHand]))
		{
			((Component)val.transform.GetChild(2).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
			{
				Log("Split Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
				pressedSplit = true;
			}));
			val.transform.GetChild(2).GetChild(2).localPosition = new Vector3(0f, 0f, -0.25f);
			((Component)val.transform.GetChild(2)).gameObject.SetActive(true);
		}
		((TMP_Text)((Component)val.transform.GetChild(3)).GetComponent<TextMeshPro>()).text = GetPlayerHandTotal()[thisHand].ToString();
		val.transform.GetChild(3).localPosition = new Vector3(-0.15f, 0f, 0.6f);
		((Component)val.transform.GetChild(3)).gameObject.SetActive((bool)((ModSetting)Main.showHandCount).SavedValue);
		int num;
		for (num = dealerHand[0]; num >= 13; num -= 13)
		{
		}
		string text = Math.Min(num + 1, 10).ToString();
		((TMP_Text)((Component)val.transform.GetChild(4)).GetComponent<TextMeshPro>()).text = text;
		((Component)val.transform.GetChild(4)).gameObject.SetActive((bool)((ModSetting)Main.showHandCount).SavedValue);
		val.transform.GetChild(4).localPosition = new Vector3(-0.15f, 0f, 0.55f);
		((Component)val.transform.GetChild(4)).gameObject.SetActive((bool)((ModSetting)Main.showHandCount).SavedValue);
		Log("SpawnOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	[IteratorStateMachine(typeof(<RunOptionsMenu>d__55))]
	private IEnumerator RunOptionsMenu(int thisHand)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunOptionsMenu>d__55(0)
		{
			<>4__this = this,
			thisHand = thisHand
		};
	}

	private void ClearVisualCardsFromAHand(bool isPlayer)
	{
		Log("Clearing " + (isPlayer ? "Player's" : "Dealer's") + " Cards", (bool)((ModSetting)Main.debugging).SavedValue);
		int num = ((!isPlayer) ? 1 : 0);
		for (int i = 0; i < cardSpots.transform.GetChild(num).GetChildCount(); i++)
		{
			for (int num2 = cardSpots.transform.GetChild(num).GetChild(i).childCount - 1; num2 >= 0; num2--)
			{
				Object.Destroy((Object)(object)((Component)cardSpots.transform.GetChild(num).GetChild(i).GetChild(num2)).gameObject);
			}
		}
	}

	[IteratorStateMachine(typeof(<DrawSplit>d__57))]
	private IEnumerator DrawSplit(int thisHand, bool recreateOriginal = false)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DrawSplit>d__57(0)
		{
			<>4__this = this,
			thisHand = thisHand,
			recreateOriginal = recreateOriginal
		};
	}

	[IteratorStateMachine(typeof(<DealersTurn>d__58))]
	private IEnumerator DealersTurn()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DealersTurn>d__58(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<DealerDraw>d__59))]
	private IEnumerator DealerDraw()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DealerDraw>d__59(0)
		{
			<>4__this = this
		};
	}

	private void SetupOptionsMenu()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_025c: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if ((Object)(object)storedOptionsMenu != (Object)null)
		{
			Object.Destroy((Object)(object)storedOptionsMenu);
		}
		storedOptionsMenu = new GameObject("OptionsMenu");
		storedOptionsMenu.transform.SetParent(storedGamePartsTransform);
		storedOptionsMenu.transform.localPosition = Vector3.zero;
		storedOptionsMenu.transform.localRotation = Quaternion.identity;
		storedOptionsMenu.transform.localScale = Vector3.one;
		GameObject val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Stay", new Vector3(0.25f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val2 = tableInstance.SpawnButton(storedOptionsMenu.transform, "Hit", new Vector3(-0.25f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val3 = tableInstance.SpawnButton(storedOptionsMenu.transform, "Split", new Vector3(0f, 0f, 0.95f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val3.SetActive(false);
		GameObject val4 = tableInstance.SpawnText(storedOptionsMenu.transform, "Hand", new Vector3(-0.15f, 0f, 0.6f), Quaternion.Euler(90f, 180f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val5 = tableInstance.SpawnText(storedOptionsMenu.transform, "Hand", new Vector3(-0.15f, 0f, 0.5f), Quaternion.Euler(90f, 180f, 0f), new Vector3(0.5f, 0.5f, 0.55f));
		val5.SetActive(false);
		Log("SetupOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private bool SplitIsPossible(List<int> thisHand)
	{
		int num = thisHand[0];
		int num2 = thisHand[1];
		while (num >= 13)
		{
			num -= 13;
		}
		while (num2 >= 13)
		{
			num2 -= 13;
		}
		Log("Is Split Possible: " + (num == num2 && (tableInstance.freePlay || Main.GetPlayerCoinCount() >= betAmount + betHeldAmount)), (bool)((ModSetting)Main.debugging).SavedValue);
		return num == num2 && Main.GetPlayerCoinCount() >= betAmount + betHeldAmount;
	}

	private void UpdateBetAmountText()
	{
		((TMP_Text)betTextComponent).text = betAmount + " of " + Main.GetPlayerCoinCount();
	}
}
[RegisterTypeInIl2Cpp]
public class InteractionLever : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <PullLever>d__12 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public InteractionLever <>4__this;

		private float <fingerRotation>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PullLever>d__12(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			Quaternion localRotation;
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				localRotation = <>4__this.lastInteractedHand.transform.GetChild(3).GetChild(0).localRotation;
				<fingerRotation>5__1 = ((Quaternion)(ref localRotation)).eulerAngles.x;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.leverReleaseCoroutine == null && <fingerRotation>5__1 >= 45f)
			{
				try
				{
					localRotation = <>4__this.lastInteractedHand.transform.GetChild(3).GetChild(0).localRotation;
					<fingerRotation>5__1 = ((Quaternion)(ref localRotation)).eulerAngles.x;
					<>4__this.RotateLever();
				}
				catch
				{
					goto IL_00e5;
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			goto IL_00e5;
			IL_00e5:
			if (<>4__this.leverReleaseCoroutine == null)
			{
				<>4__this.leverReleaseCoroutine = MelonCoroutines.Start(<>4__this.ReleaseLever());
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ReleaseLever>d__14 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public InteractionLever <>4__this;

		private Delegate[] <listeners>5__1;

		private Transform <parent>5__2;

		private int <currentAngle>5__3;

		private int <rotationPerTick>5__4;

		private Delegate[] <listeners2>5__5;

		private Delegate[] <>s__6;

		private int <>s__7;

		private Delegate <listener>5__8;

		private Exception <e>5__9;

		private Delegate[] <>s__10;

		private int <>s__11;

		private Delegate <listener>5__12;

		private Exception <e>5__13;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ReleaseLever>d__14(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<listeners>5__1 = null;
			<parent>5__2 = null;
			<listeners2>5__5 = null;
			<>s__6 = null;
			<listener>5__8 = null;
			<e>5__9 = null;
			<>s__10 = null;
			<listener>5__12 = null;
			<e>5__13 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<listeners>5__1 = <>4__this.OnLeverReleased?.GetInvocationList();
				if (<listeners>5__1 != null)
				{
					<>s__6 = <listeners>5__1;
					for (<>s__7 = 0; <>s__7 < <>s__6.Length; <>s__7++)
					{
						<listener>5__8 = <>s__6[<>s__7];
						try
						{
							<listener>5__8.DynamicInvoke();
						}
						catch (Exception ex)
						{
							<e>5__9 = ex;
							MelonLogger.Msg("ReleaseLever Error for OnLeverReleased: " + <listener>5__8.Target);
							MelonLogger.Error((object)<e>5__9.InnerException);
						}
						<listener>5__8 = null;
					}
					<>s__6 = null;
				}
				<parent>5__2 = ((Component)<>4__this).transform.parent;
				Quaternion localRotation = ((Component)<parent>5__2).transform.localRotation;
				<currentAngle>5__3 = (int)((Quaternion)(ref localRotation)).eulerAngles.x;
				if (<currentAngle>5__3 < 295)
				{
					<currentAngle>5__3 += 360;
				}
				<rotationPerTick>5__4 = 1;
				break;
			}
			case 1:
				<>1__state = -1;
				<currentAngle>5__3 -= <rotationPerTick>5__4;
				<parent>5__2.localRotation = Quaternion.Euler((float)<currentAngle>5__3, 0f, 0f);
				break;
			}
			if (<currentAngle>5__3 != 295)
			{
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			<>4__this.handleActive = false;
			<listeners2>5__5 = <>4__this.OnLeverReleasedComplete?.GetInvocationList();
			if (<listeners2>5__5 != null)
			{
				<>s__10 = <listeners2>5__5;
				for (<>s__11 = 0; <>s__11 < <>s__10.Length; <>s__11++)
				{
					<listener>5__12 = <>s__10[<>s__11];
					try
					{
						<listener>5__12.DynamicInvoke();
					}
					catch (Exception ex)
					{
						<e>5__13 = ex;
						MelonLogger.Msg("ReleaseLever Error for OnLeverReleasedComplete: " + <listener>5__12.Target);
						MelonLogger.Error((object)<e>5__13.InnerException);
					}
					<listener>5__12 = null;
				}
				<>s__10 = null;
			}
			<>4__this.leverReleaseCoroutine = null;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private bool leftHandIn = false;

	private bool rightHandIn = false;

	private bool handleActive = false;

	public Action LeverPulled;

	public Action OnLeverReleased;

	public Action OnLeverReleasedComplete;

	public object leverReleaseCoroutine = null;

	public GameObject lastInteractedHand;

	public Player lastInteractedPlayer;

	private void OnTriggerEnter(Collider other)
	{
		if (!(((Object)((Component)other).gameObject).name != "Bone_HandAlpha_L") || !(((Object)((Component)other).gameObject).name != "Bone_HandAlpha_R"))
		{
			if (((Object)((Component)other).gameObject).name == "Bone_HandAlpha_L")
			{
				leftHandIn = true;
			}
			if (((Object)((Component)other).gameObject).name == "Bone_HandAlpha_R")
			{
				rightHandIn = true;
			}
		}
	}

	private void OnTriggerExit(Collider other)
	{
		if (!(((Object)((Component)other).gameObject).name != "Bone_HandAlpha_L") || !(((Object)((Component)other).gameObject).name != "Bone_HandAlpha_R"))
		{
			if (((Object)((Component)other).gameObject).name == "Bone_HandAlpha_L")
			{
				leftHandIn = false;
			}
			if (((Object)((Component)other).gameObject).name == "Bone_HandAlpha_R")
			{
				rightHandIn = false;
			}
		}
	}

	private void OnTriggerStay(Collider other)
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		if (((Object)((Component)other).gameObject).name != "Bone_HandAlpha_L" && ((Object)((Component)other).gameObject).name != "Bone_HandAlpha_R")
		{
			return;
		}
		lastInteractedHand = ((Component)other).gameObject;
		lastInteractedPlayer = ((Component)lastInteractedHand.transform.parent.parent.parent.parent.parent.parent.parent.parent.parent).GetComponent<PlayerController>().AssignedPlayer;
		Quaternion rotation;
		if (leftHandIn)
		{
			if (!handleActive)
			{
				rotation = lastInteractedHand.transform.GetChild(3).GetChild(0).rotation;
				if (((Quaternion)(ref rotation)).eulerAngles.x >= 45f)
				{
					handleActive = true;
					MelonCoroutines.Start(PullLever());
				}
			}
		}
		else if (rightHandIn && !handleActive)
		{
			rotation = lastInteractedHand.transform.GetChild(3).GetChild(0).rotation;
			if (((Quaternion)(ref rotation)).eulerAngles.x >= 45f)
			{
				handleActive = true;
				MelonCoroutines.Start(PullLever());
			}
		}
	}

	[IteratorStateMachine(typeof(<PullLever>d__12))]
	private IEnumerator PullLever()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PullLever>d__12(0)
		{
			<>4__this = this
		};
	}

	private void RotateLever()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: 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_0096: 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)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		Transform parent = ((Component)this).transform.parent;
		parent.LookAt(lastInteractedHand.transform.position);
		Quaternion localRotation = parent.localRotation;
		parent.localRotation = Quaternion.Euler(((Quaternion)(ref localRotation)).eulerAngles.x, 0f, 0f);
		localRotation = parent.localRotation;
		if (((Quaternion)(ref localRotation)).eulerAngles.x < 295f)
		{
			parent.localRotation = Quaternion.Euler(295f, 0f, 0f);
			return;
		}
		localRotation = parent.localRotation;
		if (!(((Quaternion)(ref localRotation)).eulerAngles.x >= 340f))
		{
			return;
		}
		parent.localRotation = Quaternion.Euler(340f, 0f, 0f);
		leverReleaseCoroutine = MelonCoroutines.Start(ReleaseLever());
		Delegate[] array = LeverPulled?.GetInvocationList();
		if (array == null)
		{
			return;
		}
		Delegate[] array2 = array;
		foreach (Delegate @delegate in array2)
		{
			try
			{
				@delegate.DynamicInvoke();
			}
			catch (Exception ex)
			{
				MelonLogger.Msg("RotateLever Error for LeverPulled: " + @delegate.Target);
				MelonLogger.Error((object)ex.InnerException);
			}
		}
	}

	[IteratorStateMachine(typeof(<ReleaseLever>d__14))]
	private IEnumerator ReleaseLever()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ReleaseLever>d__14(0)
		{
			<>4__this = this
		};
	}
}
public enum PayoutResult
{
	Nothing,
	JacksOrBetter,
	TwoPair,
	ThreeOfAKind,
	Straight,
	Flush,
	FullHouse,
	FourOfAKind,
	StraightFlush,
	RoyalFlush
}
public enum CardSuits
{
	Spades,
	Hearts,
	Diamonds,
	Clubs
}
public class JacksOrBetter : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <>c__DisplayClass25_0
	{
		public bool continuePressed;

		internal void <GameLoop>b__0()
		{
			continuePressed = true;
		}
	}

	[CompilerGenerated]
	private sealed class <CheckPayout>d__27 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private object <payoutCoroutine>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <CheckPayout>d__27(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<payoutCoroutine>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("CheckPayout Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.thisHandsPayout = <>4__this.GetWinType();
				<>4__this.coinsGained = Main.Payout(<>4__this.betAmount, <>4__this.payoutsAmounts[(int)<>4__this.thisHandsPayout], <>4__this.tableInstance);
				Log($"Hand Contains: {<>4__this.payoutsString[(int)<>4__this.thisHandsPayout]}, Paying Out: {<>4__this.coinsGained}");
				<payoutCoroutine>5__1 = null;
				if (<>4__this.thisHandsPayout == PayoutResult.Nothing)
				{
					<payoutCoroutine>5__1 = MelonCoroutines.Start(<>4__this.PlayPlayerLose());
				}
				else
				{
					<payoutCoroutine>5__1 = MelonCoroutines.Start(<>4__this.PlayPlayerWin());
				}
				<>2__current = <payoutCoroutine>5__1;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Log("CheckPayout Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DrawStartingHand>d__47 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DrawStartingHand>d__47(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("DrawStartingHand Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.hand.Add(<>4__this.DrawCard());
				Log("Player Card 1: " + <>4__this.tableInstance.CardString[<>4__this.hand[0]], (bool)((ModSetting)Main.debugging).SavedValue);
				<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[0], <>4__this.cardSpots.transform.GetChild(0), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.hand.Add(<>4__this.DrawCard());
				Log("Player Card 2: " + <>4__this.tableInstance.CardString[<>4__this.hand[1]], (bool)((ModSetting)Main.debugging).SavedValue);
				<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[1], <>4__this.cardSpots.transform.GetChild(1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.hand.Add(<>4__this.DrawCard());
				Log("Player Card 3: " + <>4__this.tableInstance.CardString[<>4__this.hand[2]], (bool)((ModSetting)Main.debugging).SavedValue);
				<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[2], <>4__this.cardSpots.transform.GetChild(2), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.hand.Add(<>4__this.DrawCard());
				Log("Player Card 4: " + <>4__this.tableInstance.CardString[<>4__this.hand[3]], (bool)((ModSetting)Main.debugging).SavedValue);
				<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[3], <>4__this.cardSpots.transform.GetChild(3), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.hand.Add(<>4__this.DrawCard());
				Log("Player Card 5: " + <>4__this.tableInstance.CardString[<>4__this.hand[4]], (bool)((ModSetting)Main.debugging).SavedValue);
				<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[4], <>4__this.cardSpots.transform.GetChild(4), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				Log("DrawStartingHand Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <GameLoop>d__25 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private GameObject <youBrokeAsFuck>5__1;

		private TextMeshPro <endGameTextTMP>5__2;

		private <>c__DisplayClass25_0 <>8__3;

		private GameObject <endGameText>5__4;

		private TextMeshPro <endGameTextTMP>5__5;

		private string <coinLine>5__6;

		private GameObject <continueButton>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GameLoop>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<youBrokeAsFuck>5__1 = null;
			<endGameTextTMP>5__2 = null;
			<>8__3 = null;
			<endGameText>5__4 = null;
			<endGameTextTMP>5__5 = null;
			<coinLine>5__6 = null;
			<continueButton>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: 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_00dc: Expected O, but got Unknown
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("GameLoop Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.gameLoopRunning = true;
				goto IL_0632;
			case 1:
				<>1__state = -1;
				goto IL_00ed;
			case 2:
				<>1__state = -1;
				<>4__this.gameLoopRunning = false;
				break;
			case 3:
				<>1__state = -1;
				<>4__this.tableInstance.ClearActiveObjects();
				<>2__current = (object)new WaitForSeconds(1.5f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				if (<>4__this.userQuits)
				{
					<>4__this.gameLoopRunning = false;
				}
				if (<>4__this.betAccepted)
				{
					<>8__3 = new <>c__DisplayClass25_0();
					Log("Player Bet Accepted: " + <>4__this.betAmount);
					Main.Payout(-<>4__this.betAmount, 1f, <>4__this.tableInstance);
					<>4__this.coinsGained = 0;
					<>2__current = MelonCoroutines.Start(<>4__this.PlayHand());
					<>1__state = 5;
					return true;
				}
				goto IL_0620;
			case 5:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>2__current = MelonCoroutines.Start(<>4__this.CheckPayout());
				<>1__state = 7;
				return true;
			case 7:
				<>1__state = -1;
				<>4__this.ClearCardSpots();
				<>8__3.continuePressed = false;
				<endGameText>5__4 = <>4__this.tableInstance.SpawnText(((Component)<>4__this.activeGamePartsTransform).transform, "End Game Text", new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.5f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
				((Object)<endGameText>5__4).name = "End Game Text";
				<endGameTextTMP>5__5 = <endGameText>5__4.GetComponent<TextMeshPro>();
				((TMP_Text)<endGameTextTMP>5__5).alignment = (TextAlignmentOptions)514;
				((TMP_Text)<endGameTextTMP>5__5).enableWordWrapping = false;
				<coinLine>5__6 = ((<>4__this.coinsGained == 0) ? $"Coins Lost: {-<>4__this.betAmount}" : $"Coins Gained: {<>4__this.coinsGained - <>4__this.betAmount}");
				((TMP_Text)<endGameTextTMP>5__5).text = "Hand Contains: " + <>4__this.payoutsString[(int)<>4__this.thisHandsPayout] + Environment.NewLine + <coinLine>5__6;
				<continueButton>5__7 = <>4__this.tableInstance.LoadMenuButton("Continue", new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.96f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), delegate
				{
					<>8__3.continuePressed = true;
				});
				((Object)<continueButton>5__7).name = "Continue";
				goto IL_05db;
			case 8:
				{
					<>1__state = -1;
					goto IL_05db;
				}
				IL_0620:
				<>4__this.tableInstance.ClearActiveObjects();
				goto IL_0632;
				IL_05db:
				if (!<>8__3.continuePressed && <>4__this.gameLoopRunning)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 8;
					return true;
				}
				<>8__3 = null;
				<endGameText>5__4 = null;
				<endGameTextTMP>5__5 = null;
				<coinLine>5__6 = null;
				<continueButton>5__7 = null;
				goto IL_0620;
				IL_00ed:
				<>4__this.betAmount = 1;
				if (!<>4__this.tableInstance.freePlay && Main.GetPlayerCoinCount() < <>4__this.betAmount)
				{
					<youBrokeAsFuck>5__1 = <>4__this.tableInstance.SpawnText(((Component)<>4__this.activeGamePartsTransform).transform, "Too Few Coins. Try Free Play or" + Environment.NewLine + "Complete More Poses to Earn Coins", new Vector3(0f, <>4__this.tableInstance.TABLEHEIGHT - 0.025f, 0.65f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
					((Object)<youBrokeAsFuck>5__1).name = "You Broke As Fuck";
					<endGameTextTMP>5__2 = <youBrokeAsFuck>5__1.GetComponent<TextMeshPro>();
					((TMP_Text)<endGameTextTMP>5__2).alignment = (TextAlignmentOptions)514;
					((TMP_Text)<endGameTextTMP>5__2).enableWordWrapping = false;
					<>4__this.continueShuffling = false;
					Log("Not Enough Coins, Exiting Jacks Or Better", (bool)((ModSetting)Main.debugging).SavedValue);
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 2;
					return true;
				}
				<>4__this.tableInstance.ClearActiveObjects();
				<>2__current = MelonCoroutines.Start(<>4__this.RunBetMenu());
				<>1__state = 3;
				return true;
				IL_0632:
				if (!<>4__this.gameLoopRunning)
				{
					break;
				}
				if (<>4__this.deck.Count <= 26 * (int)((ModSetting)Main.deckCount).SavedValue)
				{
					<>4__this.RandomizeDeck(continueShuffling: false);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				goto IL_00ed;
			}
			Log("GameLoop Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayCardShrinkCoroutine>d__44 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public bool destroyAfter;

		public JacksOrBetter <>4__this;

		private Vector3 <startingScale>5__1;

		private Vector3 <scalePerTick>5__2;

		private int <i>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayCardShrinkCoroutine>d__44(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<startingScale>5__1 = card.transform.localScale;
				<scalePerTick>5__2 = <startingScale>5__1 / 50f;
				<i>5__3 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__3++;
				break;
			}
			if (<i>5__3 < 50)
			{
				Transform transform = card.transform;
				transform.localScale -= <scalePerTick>5__2;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			if (destroyAfter)
			{
				Object.Destroy((Object)(object)card);
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayCardWinCoroutine>d__45 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public bool destroyAfter;

		public JacksOrBetter <>4__this;

		private Vector3 <startingPosition>5__1;

		private Vector3 <positionPerTick>5__2;

		private object <winShrinkCoroutine>5__3;

		private int <i>5__4;

		private int <i>5__5;

		private int <i>5__6;

		private int <i>5__7;

		private int <i>5__8;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayCardWinCoroutine>d__45(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<winShrinkCoroutine>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<startingPosition>5__1 = card.transform.localPosition;
				<positionPerTick>5__2 = Vector3.up * 0.004f;
				<i>5__4 = 0;
				goto IL_00d8;
			case 1:
				<>1__state = -1;
				<i>5__4++;
				goto IL_00d8;
			case 2:
				<>1__state = -1;
				<i>5__5++;
				goto IL_013e;
			case 3:
				<>1__state = -1;
				<i>5__6++;
				goto IL_01a4;
			case 4:
				<>1__state = -1;
				<i>5__7++;
				goto IL_0229;
			case 5:
				<>1__state = -1;
				<i>5__8++;
				goto IL_0291;
			case 6:
				{
					<>1__state = -1;
					if (destroyAfter)
					{
						Object.Destroy((Object)(object)card);
					}
					return false;
				}
				IL_01a4:
				if (<i>5__6 < 25)
				{
					Transform transform = card.transform;
					transform.localPosition += <positionPerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 3;
					return true;
				}
				<winShrinkCoroutine>5__3 = MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(card));
				<i>5__7 = 0;
				goto IL_0229;
				IL_00d8:
				if (<i>5__4 < 25)
				{
					Transform transform2 = card.transform;
					transform2.localPosition += <positionPerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<i>5__5 = 0;
				goto IL_013e;
				IL_0229:
				if (<i>5__7 < 25)
				{
					Transform transform3 = card.transform;
					transform3.localPosition -= <positionPerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 4;
					return true;
				}
				<i>5__8 = 0;
				goto IL_0291;
				IL_013e:
				if (<i>5__5 < 25)
				{
					Transform transform4 = card.transform;
					transform4.localPosition -= <positionPerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 2;
					return true;
				}
				<i>5__6 = 0;
				goto IL_01a4;
				IL_0291:
				if (<i>5__8 < 25)
				{
					Transform transform5 = card.transform;
					transform5.localPosition += <positionPerTick>5__2;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 5;
					return true;
				}
				<>2__current = <winShrinkCoroutine>5__3;
				<>1__state = 6;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayDrawAnimation>d__51 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public int ticks;

		public bool playRotate;

		public JacksOrBetter <>4__this;

		private Vector3 <distancePerTick>5__1;

		private float <rotationPerTick>5__2;

		private float <currentRotationX>5__3;

		private float <currentRotationY>5__4;

		private float <currentRotationZ>5__5;

		private int <i>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayDrawAnimation>d__51(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0049: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				Log("PlayDrawAnimation Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<distancePerTick>5__1 = card.transform.localPosition / (float)ticks;
				<rotationPerTick>5__2 = 180f / (float)ticks;
				Quaternion localRotation = card.transform.localRotation;
				<currentRotationX>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.x;
				localRotation = card.transform.localRotation;
				<currentRotationY>5__4 = ((Quaternion)(ref localRotation)).eulerAngles.y;
				localRotation = card.transform.localRotation;
				<currentRotationZ>5__5 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				<i>5__6 = 0;
				break;
			}
			case 1:
				<>1__state = -1;
				<i>5__6++;
				break;
			}
			if (<i>5__6 < 25)
			{
				Transform transform = card.transform;
				transform.localPosition -= <distancePerTick>5__1;
				if (playRotate)
				{
					<currentRotationX>5__3 -= <rotationPerTick>5__2;
					card.transform.localRotation = Quaternion.Euler(<currentRotationX>5__3, <currentRotationY>5__4, <currentRotationZ>5__5);
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			Log("PlayDrawAnimation Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayHand>d__46 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayHand>d__46(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("PlayHand Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.hand = new List<int>();
				<>4__this.SetupCardSpots();
				<>2__current = MelonCoroutines.Start(<>4__this.DrawStartingHand());
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = MelonCoroutines.Start(<>4__this.RunOptionsMenu());
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = MelonCoroutines.Start(<>4__this.ReplaceMissingCardsInHand());
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				Log("PlayHand Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayPlayerLose>d__29 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private List<object> <coroutines>5__1;

		private int <i>5__2;

		private List<object>.Enumerator <>s__3;

		private object <coroutine>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayPlayerLose>d__29(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 2)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<coroutines>5__1 = null;
			<>s__3 = default(List<object>.Enumerator);
			<coroutine>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayPlayerLose Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<coroutines>5__1 = new List<object>();
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<i>5__2 = 0;
					while (<i>5__2 < 5)
					{
						<coroutines>5__1.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(<i>5__2).GetChild(0)).gameObject, destroyAfter: true)));
						<i>5__2++;
					}
					<>s__3 = <coroutines>5__1.GetEnumerator();
					<>1__state = -3;
					goto IL_0146;
				case 2:
					<>1__state = -3;
					<coroutine>5__4 = null;
					goto IL_0146;
				case 3:
					{
						<>1__state = -1;
						Log("PlayPlayerLose Completed", (bool)((ModSetting)Main.debugging).SavedValue);
						return false;
					}
					IL_0146:
					if (<>s__3.MoveNext())
					{
						<coroutine>5__4 = <>s__3.Current;
						<>2__current = <coroutine>5__4;
						<>1__state = 2;
						return true;
					}
					<>m__Finally1();
					<>s__3 = default(List<object>.Enumerator);
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 3;
					return true;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__3).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayPlayerWin>d__28 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private List<object> <coroutines>5__1;

		private int <i>5__2;

		private List<object>.Enumerator <>s__3;

		private object <coroutine>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayPlayerWin>d__28(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 3)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<coroutines>5__1 = null;
			<>s__3 = default(List<object>.Enumerator);
			<coroutine>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("PlayPlayerWin Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<coroutines>5__1 = new List<object>();
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<i>5__2 = 0;
					goto IL_0112;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					goto IL_0112;
				case 3:
					<>1__state = -3;
					<coroutine>5__4 = null;
					goto IL_0177;
				case 4:
					{
						<>1__state = -1;
						Log("PlayPlayerWin Completed", (bool)((ModSetting)Main.debugging).SavedValue);
						return false;
					}
					IL_0112:
					if (<i>5__2 < 5)
					{
						<coroutines>5__1.Add(MelonCoroutines.Start(<>4__this.PlayCardWinCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(<i>5__2).GetChild(0)).gameObject, destroyAfter: true)));
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 2;
						return true;
					}
					<>s__3 = <coroutines>5__1.GetEnumerator();
					<>1__state = -3;
					goto IL_0177;
					IL_0177:
					if (<>s__3.MoveNext())
					{
						<coroutine>5__4 = <>s__3.Current;
						<>2__current = <coroutine>5__4;
						<>1__state = 3;
						return true;
					}
					<>m__Finally1();
					<>s__3 = default(List<object>.Enumerator);
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 4;
					return true;
				}
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__3).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ReplaceMissingCardsInHand>d__48 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private int <i>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ReplaceMissingCardsInHand>d__48(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("ReplaceMissingCardsInHand Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<i>5__1 = 0;
				goto IL_015a;
			case 1:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 2;
				return true;
			case 2:
				{
					<>1__state = -1;
					goto IL_0149;
				}
				IL_015a:
				if (<i>5__1 < 5)
				{
					if (<>4__this.hand[<i>5__1] == -1)
					{
						<>4__this.hand[<i>5__1] = <>4__this.DrawCard();
						<>2__current = <>4__this.PlayDrawCardAnimation(<>4__this.hand[<i>5__1], <>4__this.cardSpots.transform.GetChild(<i>5__1), <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).position, Quaternion.Euler(-180f, 0f, 0f));
						<>1__state = 1;
						return true;
					}
					goto IL_0149;
				}
				Log("ReplaceMissingCardsInHand Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
				IL_0149:
				<i>5__1++;
				goto IL_015a;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <Run>d__20 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <Run>d__20(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("Run Running", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.SetupStart();
				<>4__this.gameLoopCoroutine = MelonCoroutines.Start(<>4__this.GameLoop());
				<>2__current = <>4__this.gameLoopCoroutine;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Log("Run Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunBetMenu>d__52 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private GameObject <betsMenu>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunBetMenu>d__52(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<betsMenu>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("RunBetMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.betAmount = 1;
				<betsMenu>5__1 = <>4__this.SpawnBetsMenu();
				Log("Spawned Bets Menu, Waiting for Accepted Bet", (bool)((ModSetting)Main.debugging).SavedValue);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!<>4__this.betAccepted && !<>4__this.userQuits)
			{
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			Log("RunBetMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RunOptionsMenu>d__66 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public JacksOrBetter <>4__this;

		private GameObject <optionsMenu>5__1;

		private List<object> <cardsRemoving>5__2;

		private List<object>.Enumerator <>s__3;

		private object <coroutine>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RunOptionsMenu>d__66(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 2)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<optionsMenu>5__1 = null;
			<cardsRemoving>5__2 = null;
			<>s__3 = default(List<object>.Enumerator);
			<coroutine>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("RunOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<optionsMenu>5__1 = <>4__this.SpawnOptionsMenu();
					Log("Spawned Options Menu, Waiting for Selection", (bool)((ModSetting)Main.debugging).SavedValue);
					goto IL_009c;
				case 1:
					<>1__state = -1;
					goto IL_009c;
				case 2:
					{
						<>1__state = -3;
						<coroutine>5__4 = null;
						break;
					}
					IL_009c:
					if (!<>4__this.pressedContinue)
					{
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 1;
						return true;
					}
					Object.Destroy((Object)(object)<optionsMenu>5__1);
					Log($"Keep / Remove List: {<>4__this.removeCard1} {<>4__this.removeCard2} {<>4__this.removeCard3} {<>4__this.removeCard4} {<>4__this.removeCard5}", (bool)((ModSetting)Main.debugging).SavedValue);
					<cardsRemoving>5__2 = new List<object>();
					if (<>4__this.removeCard1)
					{
						Log("Removing Card 1", (bool)((ModSetting)Main.debugging).SavedValue);
						<cardsRemoving>5__2.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(0).GetChild(0)).gameObject, destroyAfter: true)));
						<>4__this.hand[0] = -1;
					}
					if (<>4__this.removeCard2)
					{
						Log("Removing Card 2", (bool)((ModSetting)Main.debugging).SavedValue);
						<cardsRemoving>5__2.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(1).GetChild(0)).gameObject, destroyAfter: true)));
						<>4__this.hand[1] = -1;
					}
					if (<>4__this.removeCard3)
					{
						Log("Removing Card 3", (bool)((ModSetting)Main.debugging).SavedValue);
						<cardsRemoving>5__2.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(2).GetChild(0)).gameObject, destroyAfter: true)));
						<>4__this.hand[2] = -1;
					}
					if (<>4__this.removeCard4)
					{
						Log("Removing Card 4", (bool)((ModSetting)Main.debugging).SavedValue);
						<cardsRemoving>5__2.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(3).GetChild(0)).gameObject, destroyAfter: true)));
						<>4__this.hand[3] = -1;
					}
					if (<>4__this.removeCard5)
					{
						Log("Removing Card 5", (bool)((ModSetting)Main.debugging).SavedValue);
						<cardsRemoving>5__2.Add(MelonCoroutines.Start(<>4__this.PlayCardShrinkCoroutine(((Component)<>4__this.cardSpots.transform.GetChild(4).GetChild(0)).gameObject, destroyAfter: true)));
						<>4__this.hand[4] = -1;
					}
					<>s__3 = <cardsRemoving>5__2.GetEnumerator();
					<>1__state = -3;
					break;
				}
				if (<>s__3.MoveNext())
				{
					<coroutine>5__4 = <>s__3.Current;
					<>2__current = <coroutine>5__4;
					<>1__state = 2;
					return true;
				}
				<>m__Finally1();
				<>s__3 = default(List<object>.Enumerator);
				Log("RunOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__3).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ShufflingCard>d__57 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public object spinCoroutine;

		public JacksOrBetter <>4__this;

		private Transform <cardsParent>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ShufflingCard>d__57(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<cardsParent>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<cardsParent>5__1 = <>4__this.tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).GetChild(0);
				<>2__current = spinCoroutine;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				break;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				break;
			}
			if (<>4__this.continueShuffling && (Object)(object)<>4__this.tableInstance.jacksOrBetterInstance != (Object)null)
			{
				spinCoroutine = MelonCoroutines.Start(<>4__this.tableInstance.SpinCard(card));
				<>2__current = spinCoroutine;
				<>1__state = 2;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private string[] payoutsString = new string[10] { "Nothing", "Jacks or Better", "Two Pair", "Three of a Kind", "Straight", "Flush", "Full House", "Four of a Kind", "Straight Flush", "Royal Flush" };

	private float[] payoutsAmounts = new float[10] { 0f, 1f, 2f, 3f, 4f, 6f, 9f, 25f, 50f, 976f };

	private int betAmount = 1;

	private bool gameLoopRunning = false;

	private TextMeshPro betTextComponent = null;

	private GameObject storedBetsMenu = null;

	private GameObject storedOptionsMenu = null;

	private bool betAccepted = false;

	private bool userQuits = false;

	private List<int> deck;

	private List<int> hand;

	public object gameLoopCoroutine = null;

	private Transform storedGamePartsTransform = null;

	private Transform activeGamePartsTransform = null;

	private Table tableInstance;

	private GameObject cardSpots = null;

	private int coinsGained = 0;

	private PayoutResult thisHandsPayout = PayoutResult.Nothing;

	private bool continueShuffling = true;

	private bool pressedContinue;

	private bool removeCard1 = true;

	private bool removeCard2 = true;

	private bool removeCard3 = true;

	private bool removeCard4 = true;

	private bool removeCard5 = true;

	public JacksOrBetter(Table tableInstance)
	{
		this.tableInstance = tableInstance;
	}

	public static void Log(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Table.Log("JacksOrBetter - " + msg, sendMsg);
		}
	}

	public static void Warn(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Table.Warn("JacksOrBetter - " + msg, sendMsg);
		}
	}

	public static void Error(string msg)
	{
		Table.Error("JacksOrBetter - " + msg);
	}

	public void ShowSplash()
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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)
		storedGamePartsTransform = ((Component)tableInstance).transform.GetChild(1);
		activeGamePartsTransform = ((Component)tableInstance).transform.GetChild(2);
		GameObject val = new GameObject("SplashScreen");
		val.transform.SetParent(activeGamePartsTransform);
		val.transform.localPosition = new Vector3(0f, 0.9454f, 0f);
		val.transform.localRotation = Quaternion.identity;
		val.transform.localScale = Vector3.one;
		GameObject val2 = tableInstance.SpawnText(val.transform, "Jacks or Better", new Vector3(0f, 0f, 0.4f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1.25f, 1.25f, 1.25f));
		TextMeshPro component = val2.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
	}

	[IteratorStateMachine(typeof(<Run>d__20))]
	public IEnumerator Run()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <Run>d__20(0)
		{
			<>4__this = this
		};
	}

	private void SetupStart()
	{
		Log("SetupStart Running", (bool)((ModSetting)Main.debugging).SavedValue);
		gameLoopRunning = false;
		RandomizeDeck();
		SetupBetMenu();
		SetupOptionsMenu();
		Log("SetupStart Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void SetupCardSpots()
	{
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupStart Started", (bool)((ModSetting)Main.debugging).SavedValue);
		cardSpots = Object.Instantiate<GameObject>(((Component)storedGamePartsTransform.GetChild(2)).gameObject);
		((Object)cardSpots).name = "CardSpots";
		cardSpots.transform.SetParent(activeGamePartsTransform);
		cardSpots.transform.localPosition = Vector3.zero;
		cardSpots.transform.localRotation = Quaternion.identity;
		cardSpots.transform.localScale = Vector3.one;
		Log("SetupStart Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	[IteratorStateMachine(typeof(<GameLoop>d__25))]
	private IEnumerator GameLoop()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GameLoop>d__25(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<CheckPayout>d__27))]
	private IEnumerator CheckPayout()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <CheckPayout>d__27(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<PlayPlayerWin>d__28))]
	private IEnumerator PlayPlayerWin()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayPlayerWin>d__28(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<PlayPlayerLose>d__29))]
	private IEnumerator PlayPlayerLose()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayPlayerLose>d__29(0)
		{
			<>4__this = this
		};
	}

	private PayoutResult GetWinType()
	{
		if (HasRoyalFlush())
		{
			return PayoutResult.RoyalFlush;
		}
		if (HasStraightFlush())
		{
			return PayoutResult.StraightFlush;
		}
		if (HasFourOfAKind())
		{
			return PayoutResult.FourOfAKind;
		}
		if (HasFullHouse())
		{
			return PayoutResult.FullHouse;
		}
		if (HasFlush())
		{
			return PayoutResult.Flush;
		}
		if (HasStraight())
		{
			return PayoutResult.Straight;
		}
		if (HasThreeOfAKind())
		{
			return PayoutResult.ThreeOfAKind;
		}
		if (HasTwoPair())
		{
			return PayoutResult.TwoPair;
		}
		if (HasJacksOrBetter())
		{
			return PayoutResult.JacksOrBetter;
		}
		return PayoutResult.Nothing;
	}

	private bool HasJacksOrBetter()
	{
		List<int> list = new List<int>();
		foreach (int item in hand)
		{
			list.Add(getCardValue(item));
		}
		List<int> list2 = new List<int>();
		for (int i = 0; i < 13; i++)
		{
			list2.Add(0);
		}
		foreach (int item2 in list)
		{
			list2[item2 - 1]++;
		}
		return list2[0] >= 2 || list2[10] >= 2 || list2[11] >= 2 || list2[12] >= 2;
	}

	private bool HasTwoPair()
	{
		List<int> list = new List<int>();
		foreach (int item in hand)
		{
			list.Add(getCardValue(item));
		}
		List<int> list2 = new List<int>();
		for (int i = 0; i < 13; i++)
		{
			list2.Add(0);
		}
		foreach (int item2 in list)
		{
			list2[item2 - 1]++;
		}
		bool result = false;
		if (list2.Contains(2))
		{
			list2.Remove(2);
			if (list2.Contains(2))
			{
				result = true;
			}
		}
		return result;
	}

	private bool HasThreeOfAKind()
	{
		return HasXOfAKind(3);
	}

	private bool HasFourOfAKind()
	{
		return HasXOfAKind(4);
	}

	private bool HasFullHouse()
	{
		List<int> list = new List<int>();
		foreach (int item in hand)
		{
			list.Add(getCardValue(item));
		}
		List<int> list2 = new List<int>();
		for (int i = 0; i < 13; i++)
		{
			list2.Add(0);
		}
		foreach (int item2 in list)
		{
			list2[item2 - 1]++;
		}
		list2.Sort();
		return list2[12] == 3 && list2[11] == 2;
	}

	private bool HasStraightFlush()
	{
		return HasFlush() && HasStraight();
	}

	private bool HasRoyalFlush()
	{
		return HasFlush() && DoesHandContainCardValue(1) && DoesHandContainCardValue(10) && DoesHandContainCardValue(11) && DoesHandContainCardValue(12) && DoesHandContainCardValue(13);
	}

	private bool HasStraight()
	{
		List<int> list = new List<int>();
		foreach (int item in hand)
		{
			list.Add(getCardValue(item));
		}
		list.Sort();
		bool flag = false;
		bool flag2 = false;
		if (list[0] == 1)
		{
			flag = true;
			list.Add(list[0]);
		}
		bool result = true;
		for (int i = 0; i < list.Count - 1; i++)
		{
			if (list[i] + 1 != list[i + 1])
			{
				if (!flag || flag2)
				{
					result = false;
					break;
				}
				flag2 = true;
			}
		}
		return result;
	}

	private bool HasFlush()
	{
		CardSuits[] array = new CardSuits[5]
		{
			getCardSuit(hand[0]),
			getCardSuit(hand[1]),
			getCardSuit(hand[2]),
			getCardSuit(hand[3]),
			getCardSuit(hand[4])
		};
		return array[0] == array[1] && array[0] == array[2] && array[0] == array[3] && array[0] == array[4];
	}

	private bool DoesHandContainCardValue(int cardNumberToFind)
	{
		return getCardValue(hand[0]) == cardNumberToFind || getCardValue(hand[1]) == cardNumberToFind || getCardValue(hand[2]) == cardNumberToFind || getCardValue(hand[3]) == cardNumberToFind || getCardValue(hand[4]) == cardNumberToFind;
	}

	private bool HasXOfAKind(int x)
	{
		List<int> list = new List<int>();
		foreach (int item in hand)
		{
			list.Add(getCardValue(item));
		}
		List<int> list2 = new List<int>();
		for (int i = 0; i < 13; i++)
		{
			list2.Add(0);
		}
		foreach (int item2 in list)
		{
			list2[item2 - 1]++;
		}
		list2.Sort();
		return x <= list2[12];
	}

	private int getCardValue(int rawCard)
	{
		int num;
		for (num = rawCard; num >= 13; num -= 13)
		{
		}
		return num + 1;
	}

	private CardSuits getCardSuit(int rawCard)
	{
		int num = rawCard;
		CardSuits cardSuits = CardSuits.Spades;
		while (num >= 13)
		{
			num -= 13;
			cardSuits++;
		}
		return cardSuits;
	}

	[IteratorStateMachine(typeof(<PlayCardShrinkCoroutine>d__44))]
	private IEnumerator PlayCardShrinkCoroutine(GameObject card, bool destroyAfter = false)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayCardShrinkCoroutine>d__44(0)
		{
			<>4__this = this,
			card = card,
			destroyAfter = destroyAfter
		};
	}

	[IteratorStateMachine(typeof(<PlayCardWinCoroutine>d__45))]
	private IEnumerator PlayCardWinCoroutine(GameObject card, bool destroyAfter = false)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayCardWinCoroutine>d__45(0)
		{
			<>4__this = this,
			card = card,
			destroyAfter = destroyAfter
		};
	}

	[IteratorStateMachine(typeof(<PlayHand>d__46))]
	private IEnumerator PlayHand()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayHand>d__46(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<DrawStartingHand>d__47))]
	private IEnumerator DrawStartingHand()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DrawStartingHand>d__47(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<ReplaceMissingCardsInHand>d__48))]
	private IEnumerator ReplaceMissingCardsInHand()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ReplaceMissingCardsInHand>d__48(0)
		{
			<>4__this = this
		};
	}

	private object PlayDrawCardAnimation(int CardToDraw, Transform parent, Vector3 position, Quaternion localRotation, bool playRotate = true)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		Log("PlayDrawCardAnimation Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(((Component)tableInstance.storedDeckOfCards.transform.GetChild(CardToDraw)).gameObject);
		val.transform.SetParent(parent);
		val.transform.position = position;
		val.transform.localRotation = localRotation;
		Log("PlayDrawCardAnimation Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return MelonCoroutines.Start(PlayDrawAnimation(val, 25, playRotate));
	}

	private int DrawCard()
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if (deck.Count == 0)
		{
			RandomizeDeck();
		}
		int result = deck[0];
		deck.RemoveAt(0);
		tableInstance.dealerDeck.transform.localScale = new Vector3(1f, (float)deck.Count / 52f, 1f);
		return result;
	}

	[IteratorStateMachine(typeof(<PlayDrawAnimation>d__51))]
	private IEnumerator PlayDrawAnimation(GameObject card, int ticks = 25, bool playRotate = true)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayDrawAnimation>d__51(0)
		{
			<>4__this = this,
			card = card,
			ticks = ticks,
			playRotate = playRotate
		};
	}

	[IteratorStateMachine(typeof(<RunBetMenu>d__52))]
	private IEnumerator RunBetMenu()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunBetMenu>d__52(0)
		{
			<>4__this = this
		};
	}

	private GameObject SpawnBetsMenu()
	{
		//IL_005a: 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)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		Log("SpawnBetsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(storedBetsMenu);
		val.transform.SetParent(activeGamePartsTransform);
		val.transform.localPosition = new Vector3(0f, tableInstance.TABLEHEIGHT - 0.052f, 0f);
		val.transform.localRotation = Quaternion.identity;
		val.transform.localScale = Vector3.one;
		betTextComponent = ((Component)val.transform.GetChild(1)).GetComponent<TextMeshPro>();
		UpdateBetAmountText();
		((Component)val.transform.GetChild(2).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Down Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (1 < betAmount)
			{
				betAmount--;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(3).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Up Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (Main.GetPlayerCoinCount() >= betAmount + 1)
			{
				betAmount++;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(4).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Down Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (10 < betAmount)
			{
				betAmount -= 10;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(5).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Up Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			if (Main.GetPlayerCoinCount() >= betAmount + 10)
			{
				betAmount += 10;
				Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
				UpdateBetAmountText();
			}
		}));
		((Component)val.transform.GetChild(6).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Accepted: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			betAccepted = true;
			continueShuffling = false;
		}));
		((Component)val.transform.GetChild(7).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("User Quit During Betting", (bool)((ModSetting)Main.debugging).SavedValue);
			userQuits = true;
			continueShuffling = false;
		}));
		((Component)val.transform.GetChild(8).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Min Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			betAmount = 1;
			Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			UpdateBetAmountText();
		}));
		((Component)val.transform.GetChild(9).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Bet Max Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			betAmount = Main.GetPlayerCoinCount();
			Log("New Bet: " + betAmount, (bool)((ModSetting)Main.debugging).SavedValue);
			UpdateBetAmountText();
		}));
		val.transform.GetChild(9).GetChild(2).localPosition = new Vector3(0f, 0f, -0.25f);
		betAccepted = false;
		userQuits = false;
		Log("SpawnBetsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	private void RandomizeDeck(bool continueShuffling = true)
	{
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		Log("RandomizeDeck Running", (bool)((ModSetting)Main.debugging).SavedValue);
		object[] shufflings = tableInstance.ShuffleDealerDeck();
		if (continueShuffling)
		{
			ContinueShufflings(shufflings);
		}
		deck = new List<int>();
		List<int> list = new List<int>();
		int num = 0;
		for (int i = 0; i < 52 * (int)((ModSetting)Main.deckCount).SavedValue; i++)
		{
			deck.Add(num);
			num++;
			if (num == 52)
			{
				num = 0;
			}
		}
		Log("Deck Setup Done", (bool)((ModSetting)Main.debugging).SavedValue);
		tableInstance.dealerDeck.transform.localScale = new Vector3(1f, (float)deck.Count / 52f, 1f);
		list.Clear();
		while (deck.Count > 0)
		{
			int index = tableInstance.random.Next(deck.Count);
			list.Add(deck[index]);
			deck.RemoveAt(index);
		}
		deck.AddRange(list);
		Log("RandomizeDeck Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void ContinueShufflings(object[] shufflings)
	{
		continueShuffling = true;
		Transform child = tableInstance.dealerDeck.transform.GetChild(0).GetChild(0).GetChild(0);
		for (int i = 0; i < shufflings.Length; i++)
		{
			MelonCoroutines.Start(ShufflingCard(((Component)((Component)child).transform.GetChild(i)).gameObject, shufflings[i]));
		}
	}

	[IteratorStateMachine(typeof(<ShufflingCard>d__57))]
	private IEnumerator ShufflingCard(GameObject card, object spinCoroutine)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ShufflingCard>d__57(0)
		{
			<>4__this = this,
			card = card,
			spinCoroutine = spinCoroutine
		};
	}

	private void SetupBetMenu()
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0276: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_032a: Unknown result type (might be due to invalid IL or missing references)
		//IL_033e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0352: Unknown result type (might be due to invalid IL or missing references)
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_0398: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_03de: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0406: Unknown result type (might be due to invalid IL or missing references)
		//IL_0438: Unknown result type (might be due to invalid IL or missing references)
		//IL_044c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0460: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupBetMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if ((Object)(object)storedBetsMenu != (Object)null)
		{
			Object.Destroy((Object)(object)storedBetsMenu);
		}
		storedBetsMenu = new GameObject("BetsMenu");
		storedBetsMenu.transform.SetParent(storedGamePartsTransform);
		storedBetsMenu.transform.localPosition = Vector3.zero;
		storedBetsMenu.transform.localRotation = Quaternion.identity;
		storedBetsMenu.transform.localScale = Vector3.one;
		GameObject val = tableInstance.SpawnText(storedBetsMenu.transform, "How Much To Bet?", new Vector3(0f, 0f, 0.35f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1.25f, 1.25f, 1.25f));
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
		GameObject val2 = tableInstance.SpawnText(storedBetsMenu.transform, "BetText", new Vector3(0f, 0f, 0.5f), Quaternion.Euler(90f, 180f, 0f), new Vector3(1f, 1f, 1f));
		TextMeshPro component2 = val2.GetComponent<TextMeshPro>();
		((TMP_Text)component2).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component2).enableWordWrapping = false;
		betTextComponent = val2.GetComponent<TextMeshPro>();
		UpdateBetAmountText();
		GameObject val3 = tableInstance.SpawnButton(storedBetsMenu.transform, "-1", new Vector3(0.15f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val4 = tableInstance.SpawnButton(storedBetsMenu.transform, "+1", new Vector3(-0.15f, 0f, 0.9f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val5 = tableInstance.SpawnButton(storedBetsMenu.transform, "-10", new Vector3(0.325f, 0f, 0.85f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val6 = tableInstance.SpawnButton(storedBetsMenu.transform, "+10", new Vector3(-0.325f, 0f, 0.85f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val7 = tableInstance.SpawnButton(storedBetsMenu.transform, "Accept", new Vector3(0f, 0f, 0.75f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val8 = tableInstance.SpawnButton(storedBetsMenu.transform, "Exit", new Vector3(0.75f, 0f, 0.25f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val9 = tableInstance.SpawnButton(storedBetsMenu.transform, "Min", new Vector3(0.5f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val10 = tableInstance.SpawnButton(storedBetsMenu.transform, "Max", new Vector3(-0.5f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		Log("SetupBetMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private GameObject SpawnOptionsMenu()
	{
		//IL_00a0: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		Log("SpawnOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		pressedContinue = false;
		removeCard1 = true;
		removeCard2 = true;
		removeCard3 = true;
		removeCard4 = true;
		removeCard5 = true;
		GameObject spawnedOptionsMenu = Object.Instantiate<GameObject>(storedOptionsMenu);
		spawnedOptionsMenu.transform.SetParent(activeGamePartsTransform);
		spawnedOptionsMenu.transform.localPosition = new Vector3(0f, tableInstance.TABLEHEIGHT - 0.052f, 0f);
		spawnedOptionsMenu.transform.localRotation = Quaternion.identity;
		spawnedOptionsMenu.transform.localScale = Vector3.one;
		((Component)spawnedOptionsMenu.transform.GetChild(0).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Card 1 Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			removeCard1 = !removeCard1;
			((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).text = (removeCard1 ? "Remove" : "Keep");
		}));
		((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).text = "Remove";
		((Component)spawnedOptionsMenu.transform.GetChild(1).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Card 2 Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			removeCard2 = !removeCard2;
			((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).text = (removeCard2 ? "Remove" : "Keep");
		}));
		((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).text = "Remove";
		((Component)spawnedOptionsMenu.transform.GetChild(2).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Card 3 Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			removeCard3 = !removeCard3;
			((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).text = (removeCard3 ? "Remove" : "Keep");
		}));
		((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).text = "Remove";
		((Component)spawnedOptionsMenu.transform.GetChild(3).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Card 4 Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			removeCard4 = !removeCard4;
			((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(3).GetChild(2)).GetComponent<TextMeshPro>()).text = (removeCard4 ? "Remove" : "Keep");
		}));
		((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(3).GetChild(2)).GetComponent<TextMeshPro>()).text = "Remove";
		((Component)spawnedOptionsMenu.transform.GetChild(4).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Card 5 Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			removeCard5 = !removeCard5;
			((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(4).GetChild(2)).GetComponent<TextMeshPro>()).text = (removeCard5 ? "Remove" : "Keep");
		}));
		((TMP_Text)((Component)spawnedOptionsMenu.transform.GetChild(4).GetChild(2)).GetComponent<TextMeshPro>()).text = "Remove";
		((Component)spawnedOptionsMenu.transform.GetChild(5).GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
		{
			Log("Continue Pressed", (bool)((ModSetting)Main.debugging).SavedValue);
			pressedContinue = true;
		}));
		spawnedOptionsMenu.transform.GetChild(5).GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		Log("SpawnOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
		return spawnedOptionsMenu;
	}

	[IteratorStateMachine(typeof(<RunOptionsMenu>d__66))]
	private IEnumerator RunOptionsMenu()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RunOptionsMenu>d__66(0)
		{
			<>4__this = this
		};
	}

	private void ClearCardSpots()
	{
		Log("Clearing Card Spots", (bool)((ModSetting)Main.debugging).SavedValue);
		for (int i = 0; i < cardSpots.transform.GetChildCount(); i++)
		{
			for (int num = cardSpots.transform.GetChild(i).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)cardSpots.transform.GetChild(i).GetChild(num)).gameObject);
			}
		}
	}

	private void SetupOptionsMenu()
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Expected O, but got Unknown
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_022d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0311: Unknown result type (might be due to invalid IL or missing references)
		//IL_036b: Unknown result type (might be due to invalid IL or missing references)
		//IL_037f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0393: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_0414: Unknown result type (might be due to invalid IL or missing references)
		//IL_0428: Unknown result type (might be due to invalid IL or missing references)
		//IL_043c: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupOptionsMenu Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if ((Object)(object)storedOptionsMenu != (Object)null)
		{
			Object.Destroy((Object)(object)storedOptionsMenu);
		}
		storedOptionsMenu = new GameObject("OptionsMenu");
		storedOptionsMenu.transform.SetParent(storedGamePartsTransform);
		storedOptionsMenu.transform.localPosition = Vector3.zero;
		storedOptionsMenu.transform.localRotation = Quaternion.identity;
		storedOptionsMenu.transform.localScale = Vector3.one;
		GameObject val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Card1", new Vector3(0.2456f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val.transform.GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		TextMeshPro component = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshPro>();
		((TMP_Text)component).fontSize = 0.75f;
		((TMP_Text)component).text = "Remove";
		val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Card2", new Vector3(0.1228f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val.transform.GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		component = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshPro>();
		((TMP_Text)component).fontSize = 0.75f;
		((TMP_Text)component).text = "Remove";
		val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Card3", new Vector3(0f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val.transform.GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		component = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshPro>();
		((TMP_Text)component).fontSize = 0.75f;
		((TMP_Text)component).text = "Remove";
		val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Card4", new Vector3(-0.1228f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val.transform.GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		component = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshPro>();
		((TMP_Text)component).fontSize = 0.75f;
		((TMP_Text)component).text = "Remove";
		val = tableInstance.SpawnButton(storedOptionsMenu.transform, "Card5", new Vector3(-0.2456f, 0f, 0.8f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		val.transform.GetChild(2).localPosition = new Vector3(0f, 0f, -0.2f);
		component = ((Component)val.transform.GetChild(2)).GetComponent<TextMeshPro>();
		((TMP_Text)component).fontSize = 0.75f;
		((TMP_Text)component).text = "Remove";
		tableInstance.SpawnButton(storedOptionsMenu.transform, "Continue", new Vector3(-0.43f, 0f, 0.86f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		Log("SetupOptionsMenu Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void UpdateBetAmountText()
	{
		((TMP_Text)betTextComponent).text = betAmount + " of " + Main.GetPlayerCoinCount();
	}
}
public static class BuildInfo
{
	public const string ModName = "GamblingMod";

	public const string ModVersion = "2.2.4";

	public const string Author = "UlvakSkillz";
}
[HarmonyPatch(typeof(PlayerPoseSystem), "OnPoseSetCompleted", new Type[] { typeof(PoseSet) })]
public static class PosePatch
{
	private static void Postfix(PoseSet set)
	{
		Main.posesCompleted++;
		if (Main.posesCompleted >= 100)
		{
			Main.posesCompleted -= 100;
			Main.Payout(1, 1f);
			Main.Log("Player Earned 1 Coin from Completing 100 Poses");
		}
	}
}
public class Main : MelonMod
{
	[CompilerGenerated]
	private sealed class <ControlOtherLandsTransition>d__44 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		private List<Table>.Enumerator <>s__1;

		private Table <loadedTable>5__2;

		private List<SlotMachine>.Enumerator <>s__3;

		private SlotMachine <loadedSlot>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ControlOtherLandsTransition>d__44(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = default(List<Table>.Enumerator);
			<loadedTable>5__2 = null;
			<>s__3 = default(List<SlotMachine>.Enumerator);
			<loadedSlot>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>s__1 = tableList.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<loadedTable>5__2 = <>s__1.Current;
						((Component)<loadedTable>5__2).gameObject.SetActive(true);
						((Component)<loadedTable>5__2).transform.position = new Vector3(((Component)<loadedTable>5__2).transform.position.x, 0f, ((Component)<loadedTable>5__2).transform.position.z);
						<loadedTable>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Table>.Enumerator);
				<>s__3 = slotsList.GetEnumerator();
				try
				{
					while (<>s__3.MoveNext())
					{
						<loadedSlot>5__4 = <>s__3.Current;
						((Component)<loadedSlot>5__4).gameObject.SetActive(true);
						((Component)<loadedSlot>5__4).transform.position = new Vector3(((Component)<loadedSlot>5__4).transform.position.x, 0f, ((Component)<loadedSlot>5__4).transform.position.z);
						<loadedSlot>5__4 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__3).Dispose();
				}
				<>s__3 = default(List<SlotMachine>.Enumerator);
				Log("ControlOtherLandsTransition Completed", (bool)((ModSetting)debugging).SavedValue);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <GrabRumbleTextObject>d__45 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		private GameObject <originalObject>5__1;

		private GameObject <newText>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <GrabRumbleTextObject>d__45(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<originalObject>5__1 = null;
			<newText>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("GrabRumbleTextObject Started", (bool)((ModSetting)debugging).SavedValue);
				<originalObject>5__1 = null;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)<originalObject>5__1 == (Object)null)
			{
				<originalObject>5__1 = GameObject.Find("/SCENE/Text");
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			<>4__this.rumbleTextObject = new GameObject("RumbleText");
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(4)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, -5.3182f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(5)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, -2.7164f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(3)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, 0f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(0)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, 2.7673f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(2)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, 4.6371f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<newText>5__2 = Object.Instantiate<GameObject>(((Component)<originalObject>5__1.transform.GetChild(1)).gameObject);
			<newText>5__2.transform.SetParent(<>4__this.rumbleTextObject.transform);
			<newText>5__2.transform.localPosition = new Vector3(0f, 0f, 6.605f);
			<newText>5__2.transform.localRotation = Quaternion.identity;
			<newText>5__2.transform.localScale = <originalObject>5__1.transform.localScale;
			<>4__this.rumbleTextObject.transform.localScale = new Vector3(0.0001f, 0.001f, 0.001f);
			<>4__this.rumbleTextObject.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)<>4__this.rumbleTextObject);
			Log("Grabbed RUMBLE GameObject for Later", (bool)((ModSetting)debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <MapLoadCoroutine>d__41 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Main <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <MapLoadCoroutine>d__41(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("MapLoadCoroutine Started", (bool)((ModSetting)debugging).SavedValue);
				if (currentScene == "Gym" && !<>4__this.finishedGymSetup)
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				goto IL_00f6;
			case 1:
				<>1__state = -1;
				<>4__this.FinishStoredTableSetup();
				<>4__this.FinishStoredSlotsSetup();
				if ((Object)(object)GameObject.Find("/FlatLand/") != (Object)null)
				{
					flatLandFound = true;
				}
				if ((Object)(object)GameObject.Find("/VoidLand/") != (Object)null)
				{
					voidLandFound = true;
				}
				<>4__this.SetupAudio();
				<>4__this.finishedGymSetup = true;
				goto IL_00f6;
			case 2:
				{
					<>1__state = -1;
					if (flatLandFound)
					{
						GameObject.Find("/FlatLand/FlatLandButton/Button").GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
						{
							MelonCoroutines.Start(<>4__this.ControlOtherLandsTransition());
						}));
					}
					if (voidLandFound)
					{
						GameObject.Find("/VoidLand/VoidLandButton/Button").GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
						{
							MelonCoroutines.Start(<>4__this.ControlOtherLandsTransition());
						}));
					}
					break;
				}
				IL_00f6:
				if (currentScene == "Gym")
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 2;
					return true;
				}
				break;
			}
			if ((bool)((ModSetting)tableEnabled).SavedValue)
			{
				<>4__this.LoadTable();
			}
			if ((bool)((ModSetting)slotsEnabled).SavedValue)
			{
				<>4__this.LoadSlots();
			}
			Log("MapLoadCoroutine Completed", (bool)((ModSetting)debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private static Instance logger;

	public static MelonMod melonMod;

	private static int playerCoins = -1;

	public static int posesCompleted = -1;

	private static bool flatLandFound = false;

	private static bool voidLandFound = false;

	public static Mod GamblingMod = new Mod();

	public static ModSetting<int> deckCount;

	public static ModSetting<bool> tableEnabled;

	public static ModSetting<bool> slotsEnabled;

	public static ModSetting<int> tableSeed;

	public static ModSetting<int> slotsSeed;

	public static ModSetting<bool> useSeed;

	public static ModSetting<int> volume;

	public static ModSetting<bool> showHandCount;

	public static ModSetting<bool> debugging;

	public static List<Table> tableList = new List<Table>();

	public static List<SlotMachine> slotsList = new List<SlotMachine>();

	public GameObject rumbleTextObject;

	public static string currentScene = "Loader";

	private static GameObject storedTable;

	private static GameObject storedSlots;

	private bool finishedGymSetup;

	private bool lastUseSeed = false;

	private int lastdeckCount = 1;

	private int lastVolume = -1;

	private Material spinnerMaterial;

	private static Shader URPUnlit;

	public static List<AudioCall> storedAudioCalls = new List<AudioCall>();

	public static void Log(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			logger.Msg(msg);
		}
	}

	public static void Warn(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			logger.Warning(msg);
		}
	}

	public static void Error(string msg)
	{
		logger.Error(msg);
	}

	public override void OnLateInitializeMelon()
	{
		URPUnlit = Shader.Find("Universal Render Pipeline/Unlit");
		ModUIInit();
		logger = ((MelonBase)this).LoggerInstance;
		melonMod = (MelonMod)(object)this;
		Log("OnLateInitializeMelon Started", (bool)((ModSetting)debugging).SavedValue);
		LoadSaveFile();
		LoadAssetBundle();
		MelonCoroutines.Start(GrabRumbleTextObject());
		Log("OnLateInitializeMelon Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void LoadSaveFile()
	{
		Log("LoadSaveFile Started", (bool)((ModSetting)debugging).SavedValue);
		if (!Directory.Exists("UserData\\GamblingMod"))
		{
			Directory.CreateDirectory("UserData\\GamblingMod");
		}
		if (!File.Exists("UserData\\GamblingMod\\Save.save"))
		{
			EncryptStringToFile("0|0", "UserData\\GamblingMod\\Save.save", "UlvakSkillz");
		}
		try
		{
			string text = DecryptStringFromFile("UserData\\GamblingMod\\Save.save", "UlvakSkillz");
			Log("Save.save File Text: " + text, (bool)((ModSetting)debugging).SavedValue);
			string[] array = text.Split("|");
			playerCoins = int.Parse(array[0]);
			Log("Loaded Player Coins: " + playerCoins);
			posesCompleted = int.Parse(array[1]);
			Log("Loaded Poses Completed: " + posesCompleted);
		}
		catch (Exception ex)
		{
			Error("Error Loading Save File:");
			Error(ex.Message);
			if (playerCoins == -1)
			{
				Log("Failed to Load Player Coins, Setting to 0");
				playerCoins = 0;
			}
			if (posesCompleted == -1)
			{
				Log("Failed to Load Poses Completed Count, Setting to 0");
				posesCompleted = 0;
			}
		}
		Log("LoadSaveFile Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void LoadAssetBundle()
	{
		Log("LoadAssetBundle Started", (bool)((ModSetting)debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(AssetBundles.LoadAssetFromStream<GameObject>((MelonMod)(object)this, "GamblingMod.gambling", "Spinner"));
		spinnerMaterial = ((Renderer)val.GetComponent<MeshRenderer>()).material;
		Object.DontDestroyOnLoad((Object)(object)val);
		((Object)val).name = "Gambling Mod Matierial Storage";
		val.SetActive(false);
		GameObject val2 = Object.Instantiate<GameObject>(AssetBundles.LoadAssetFromStream<GameObject>((MelonMod)(object)this, "GamblingMod.gambling", "Poker"));
		storedTable = ((Component)val2.transform.GetChild(0)).gameObject;
		storedSlots = ((Component)val2.transform.GetChild(1)).gameObject;
		((Object)storedTable).name = "PokerTable";
		((Object)storedSlots).name = "SlotMachine";
		storedTable.transform.SetParent((Transform)null);
		storedSlots.transform.SetParent((Transform)null);
		storedTable.SetActive(false);
		storedSlots.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)storedTable);
		Object.DontDestroyOnLoad((Object)(object)storedSlots);
		finishedGymSetup = false;
		Object.Destroy((Object)(object)val2);
		Log("LoadAssetBundle Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private static void ChangeShaderLitToUnlit(GameObject asset)
	{
		Renderer component = asset.GetComponent<Renderer>();
		if ((Object)(object)component != (Object)null)
		{
			for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)component.materials).Length; i++)
			{
				if (((Object)((Il2CppArrayBase<Material>)(object)component.materials)[i].shader).name == "Universal Render Pipeline/Lit")
				{
					((Il2CppArrayBase<Material>)(object)component.materials)[i].shader = URPUnlit;
				}
			}
		}
		for (int j = 0; j < asset.transform.GetChildCount(); j++)
		{
			ChangeShaderLitToUnlit(((Component)asset.transform.GetChild(j)).gameObject);
		}
	}

	public void ModUIInit()
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Expected O, but got Unknown
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Expected O, but got Unknown
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Expected O, but got Unknown
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Expected O, but got Unknown
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Expected O, but got Unknown
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Expected O, but got Unknown
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Expected O, but got Unknown
		GamblingMod.ModName = "GamblingMod";
		GamblingMod.ModVersion = "2.2.4";
		GamblingMod.SetFolder("GamblingMod");
		tableEnabled = GamblingMod.AddToList("Table Enabled", true, 0, "Enables the Poker Table.", new Tags());
		slotsEnabled = GamblingMod.AddToList("Slots Enabled", true, 0, "Enables the Slot Machine.", new Tags());
		deckCount = GamblingMod.AddToList("Deck Count", 1, "Sets How Many Complete Decks should be in the Dealer Deck.", new Tags());
		showHandCount = GamblingMod.AddToList("Show Hand Count", false, 0, "BlackJack: If Enabled, Shows the Hand Counts.", new Tags());
		tableSeed = GamblingMod.AddToList("Table Seed", -1, "Sets the Seed in the Randomizer if 'Use Seed' is Toggled On.", new Tags
		{
			DoNotSave = true
		});
		slotsSeed = GamblingMod.AddToList("Slots Seed", -1, "Sets the Seed in the Randomizer if 'Use Seed' is Toggled On.", new Tags
		{
			DoNotSave = true
		});
		useSeed = GamblingMod.AddToList("Use Seed", false, 0, "If Enabled, Sets the Table to FreePlay Mode and Uses the Seed.", new Tags
		{
			DoNotSave = true
		});
		volume = GamblingMod.AddToList("Volume", 100, "Sets the Volume of Sounds. 0 - 100", new Tags
		{
			DoNotSave = true
		});
		debugging = GamblingMod.AddToList("Debugging", false, 0, "Enables Debugging Logs.", new Tags());
		GamblingMod.GetFromFile();
		lastUseSeed = (bool)((ModSetting)useSeed).SavedValue;
		UI.instance.UI_Initialized += UIInit;
		GamblingMod.ModSaved += Save;
		Actions.onMapInitialized += MapLoaded;
	}

	private void Save()
	{
		if (lastdeckCount != (int)((ModSetting)deckCount).SavedValue)
		{
			int num = Math.Max((int)((ModSetting)deckCount).SavedValue, 0);
			((ModSetting)deckCount).SavedValue = num;
			((ModSetting)deckCount).Value = num;
		}
		int num2 = Math.Clamp((int)((ModSetting)tableSeed).SavedValue, 0, 999999999);
		if (num2 != (int)((ModSetting)tableSeed).SavedValue)
		{
			((ModSetting)tableSeed).SavedValue = num2;
			((ModSetting)tableSeed).Value = num2;
		}
		num2 = Math.Clamp((int)((ModSetting)slotsSeed).SavedValue, 0, 999999999);
		if (num2 != (int)((ModSetting)slotsSeed).SavedValue)
		{
			((ModSetting)slotsSeed).SavedValue = num2;
			((ModSetting)slotsSeed).Value = num2;
		}
		if (lastVolume != (int)((ModSetting)volume).SavedValue)
		{
			num2 = Math.Clamp((int)((ModSetting)volume).SavedValue, 0, 100);
			if (num2 != (int)((ModSetting)volume).SavedValue)
			{
				((ModSetting)volume).SavedValue = num2;
				((ModSetting)volume).Value = num2;
			}
			lastVolume = (int)((ModSetting)volume).SavedValue;
			SetAudioLevels((int)((ModSetting)volume).SavedValue);
		}
		if (lastUseSeed == (bool)((ModSetting)useSeed).SavedValue)
		{
			return;
		}
		lastUseSeed = (bool)((ModSetting)useSeed).SavedValue;
		foreach (Table table in tableList)
		{
			if (lastUseSeed)
			{
				if ((Object)(object)table.freePlayButton != (Object)null)
				{
					Object.Destroy((Object)(object)table.freePlayButton);
				}
				table.freePlay = true;
			}
			if ((Object)(object)table.blackJackInstance != (Object)null)
			{
				MelonCoroutines.Stop((object)table.blackJackInstance);
			}
			if ((Object)(object)table.jacksOrBetterInstance != (Object)null)
			{
				MelonCoroutines.Stop((object)table.jacksOrBetterInstance);
			}
			table.ClearActiveObjects();
			table.SetupRandom();
			table.SetupStart();
		}
		foreach (SlotMachine slots in slotsList)
		{
			if (lastUseSeed)
			{
				slots.SetFreePlay(isFreePlay: true);
			}
			slots.SetupRandom();
		}
	}

	private void SetAudioLevels(int volumeLevel)
	{
		Log($"SetAudioLevels({volumeLevel}) Running", (bool)((ModSetting)debugging).SavedValue);
		foreach (AudioCall storedAudioCall in storedAudioCalls)
		{
			storedAudioCall.generalSettings.SetVolume((float)(volumeLevel / 100));
			storedAudioCall.spatialSettings.SpatialBlend = 1f;
		}
	}

	private void UIInit()
	{
		Log("UIInit Started", (bool)((ModSetting)debugging).SavedValue);
		UI.instance.AddMod(GamblingMod);
		Log("UIInit Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void MapLoaded(string map)
	{
		currentScene = map;
		if (!(currentScene == "Loader"))
		{
			if (logger == null)
			{
				logger = ((MelonBase)this).LoggerInstance;
			}
			if (!(map != "Gym") || !(map != "Park"))
			{
				MelonCoroutines.Start(MapLoadCoroutine());
			}
		}
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
	}

	[IteratorStateMachine(typeof(<MapLoadCoroutine>d__41))]
	private IEnumerator MapLoadCoroutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <MapLoadCoroutine>d__41(0)
		{
			<>4__this = this
		};
	}

	private void SetupAudio()
	{
		Log("SetupAudio Started", (bool)((ModSetting)debugging).SavedValue);
		storedAudioCalls.Clear();
		Transform transform = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).transform;
		Transform child = transform.GetChild(1);
		Transform transform2 = Howard.GetGameObject().transform;
		Transform transform3 = ProgressTracker.GetGameObject().transform;
		Transform transform4 = Gearmarket.GetGameObject().transform;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform2).GetComponent<HowardFX>().movementAudioCall));
		((Object)storedAudioCalls[0]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform4).GetComponent<GearMarket>().unlockClaimSFX));
		((Object)storedAudioCalls[1]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform3).GetComponent<ProgressTracker>().itemPanelFlipAudioCall));
		((Object)storedAudioCalls[2]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform4).GetComponent<GearMarket>().unlockPurchaseSFX));
		((Object)storedAudioCalls[3]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform4).GetComponent<GearMarket>().alertAudioCall));
		((Object)storedAudioCalls[4]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)child).GetComponent<PlayerScaling>().onMeasureFailedAudioCall));
		((Object)storedAudioCalls[5]).hideFlags = (HideFlags)61;
		storedAudioCalls.Add(Object.Instantiate<AudioCall>(((Component)transform).GetComponent<PlayerShiftstoneSystem>().onShiftstoneUseSFX));
		((Object)storedAudioCalls[6]).hideFlags = (HideFlags)61;
		SetAudioLevels((int)((ModSetting)volume).SavedValue);
		Log("SetupAudio Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	[IteratorStateMachine(typeof(<ControlOtherLandsTransition>d__44))]
	private IEnumerator ControlOtherLandsTransition()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ControlOtherLandsTransition>d__44(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<GrabRumbleTextObject>d__45))]
	private IEnumerator GrabRumbleTextObject()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <GrabRumbleTextObject>d__45(0)
		{
			<>4__this = this
		};
	}

	private void FinishStoredSlotsSetup()
	{
		//IL_005d: 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)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_022b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_0252: Unknown result type (might be due to invalid IL or missing references)
		Log("FinishStoredSlotsSetup Started", (bool)((ModSetting)debugging).SavedValue);
		GameObject val = Object.Instantiate<GameObject>(RevolvingNumberCollection.GetGameObject());
		((Object)val).name = "RadialDials";
		val.transform.SetParent(storedSlots.transform);
		val.transform.localPosition = new Vector3(-0.543f, 1.115f, 0.017f);
		val.transform.localRotation = Quaternion.Euler(270f, 180f, 0f);
		val.transform.localScale = new Vector3(10f, 10f, 10f);
		val.transform.GetChild(0).localPosition = new Vector3(-0.086f, 0f, 0f);
		val.transform.GetChild(2).localPosition = new Vector3(-0.04f, 0f, 0f);
		((Renderer)((Component)val.transform.GetChild(0)).GetComponent<MeshRenderer>()).material = spinnerMaterial;
		((Renderer)((Component)val.transform.GetChild(1)).GetComponent<MeshRenderer>()).material = spinnerMaterial;
		((Renderer)((Component)val.transform.GetChild(2)).GetComponent<MeshRenderer>()).material = spinnerMaterial;
		Transform transform = new GameObject("Spinner Spot Parent 0").transform;
		transform.SetParent(val.transform.GetChild(0));
		transform.localPosition = Vector3.zero;
		transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
		transform.localScale = Vector3.one;
		SetupStoredSlotsSpinner(transform);
		transform = new GameObject("Spinner Spot Parent 1").transform;
		transform.SetParent(val.transform.GetChild(1));
		transform.localPosition = Vector3.zero;
		transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
		transform.localScale = Vector3.one;
		SetupStoredSlotsSpinner(transform);
		transform = new GameObject("Spinner Spot Parent 2").transform;
		transform.SetParent(val.transform.GetChild(2));
		transform.localPosition = Vector3.zero;
		transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
		transform.localScale = Vector3.one;
		SetupStoredSlotsSpinner(transform);
		ChangeShaderLitToUnlit(storedSlots);
		Log("FinishStoredSlotsSetup Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void FinishStoredTableSetup()
	{
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: 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_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_027c: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0367: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0418: Unknown result type (might be due to invalid IL or missing references)
		Log("FinishStoredTableSetup Started", (bool)((ModSetting)debugging).SavedValue);
		ChangeShaderLitToUnlit(storedTable);
		((Component)storedTable.transform.GetChild(0).GetChild(0)).GetComponent<Renderer>().material.color = new Color(0.0969f, 0.9072f, 0.4112f);
		storedTable.transform.GetChild(0).GetChild(2).localPosition = new Vector3(0f, -0.01f, 0f);
		storedTable.transform.GetChild(0).GetChild(3).localPosition = new Vector3(0f, -0.01f, 0f);
		storedTable.transform.GetChild(0).GetChild(14).localPosition = new Vector3(0f, -0.01f, 0f);
		((Component)storedTable.transform.GetChild(0).GetChild(1)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(2)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(3)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(4)).GetComponent<Renderer>().material.color = new Color(0.0969f, 0.9072f, 0.4112f);
		((Component)storedTable.transform.GetChild(0).GetChild(5)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(6)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(7)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(8)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(9)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(10)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(11)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(12)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(13)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		((Component)storedTable.transform.GetChild(0).GetChild(14)).GetComponent<Renderer>().material.color = new Color(0.2785f, 0.4784f, 0.4823f);
		Log("FinishStoredTableSetup Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	public GameObject SpawnText(Transform parent, string title, Vector3 position, Quaternion rotation, Vector3 localScale)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: 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)
		GameObject val = Create.NewText();
		((Object)val).name = title + " Text";
		val.transform.SetParent(parent);
		val.transform.localPosition = position;
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).text = title;
		((TMP_Text)component).alignment = (TextAlignmentOptions)513;
		((TMP_Text)component).enableWordWrapping = false;
		return val;
	}

	private void SetupStoredSlotsSpinner(Transform spinner)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: 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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: 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_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_0227: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0261: Unknown result type (might be due to invalid IL or missing references)
		//IL_0281: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0326: Unknown result type (might be due to invalid IL or missing references)
		//IL_032d: Expected O, but got Unknown
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_036a: Unknown result type (might be due to invalid IL or missing references)
		//IL_037c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0409: Unknown result type (might be due to invalid IL or missing references)
		//IL_041b: Unknown result type (might be due to invalid IL or missing references)
		//IL_042d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0437: Unknown result type (might be due to invalid IL or missing references)
		//IL_044c: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupStoredSlotsSpinner Started", (bool)((ModSetting)debugging).SavedValue);
		Vector3[] array = (Vector3[])(object)new Vector3[10]
		{
			new Vector3(0.0001f, 0.001f, -0.001f),
			new Vector3(0.25f, 0f, 0.25f),
			new Vector3(0.25f, 0f, 0.25f),
			new Vector3(0.18f, 0f, 0.18f),
			new Vector3(0.25f, 0f, 0.25f),
			new Vector3(0.2f, 0f, 0.2f),
			new Vector3(0.2f, 0f, 0.2f),
			new Vector3(0.2f, 0f, 0.2f),
			new Vector3(0.2f, 0f, 0.2f),
			new Vector3(0.009f, 0.006f, 0.001f)
		};
		Quaternion[] array2 = (Quaternion[])(object)new Quaternion[10]
		{
			Quaternion.Euler(0f, 0f, 0f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(-90f, 90f, 0f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 0f, 270f),
			Quaternion.Euler(0f, 270f, 0f)
		};
		Vector3?[] array3 = new Vector3?[10]
		{
			new Vector3(-0.021f, 0f, 0.0005f),
			new Vector3(-0.021f, 0.006f, 0f),
			null,
			null,
			null,
			null,
			null,
			null,
			null,
			new Vector3(-0.021f, -0.005f, 0f)
		};
		GameObject[] array4 = (GameObject[])(object)new GameObject[10]
		{
			rumbleTextObject,
			Mesh.GetGameObject(),
			Mesh.GetGameObject(),
			Gem101.GetGameObject(),
			Mesh.GetGameObject(),
			Mesh.GetGameObject(),
			Mesh.GetGameObject(),
			Mesh.GetGameObject(),
			Mesh.GetGameObject(),
			Howard.GetGameObject()
		};
		for (int i = 0; i < 10; i++)
		{
			GameObject val = new GameObject("SpinnerSpot" + i);
			val.transform.SetParent(spinner);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.Euler(0f, 0f, 270f - (float)(i * 36));
			val.transform.localScale = Vector3.one;
			GameObject val2 = Object.Instantiate<GameObject>(array4[i]);
			val2.transform.SetParent(val.transform);
			if (array3[i].HasValue)
			{
				val2.transform.localPosition = array3[i].Value;
			}
			else
			{
				val2.transform.localPosition = new Vector3(-0.0204f, 0f, 0f);
			}
			val2.transform.localRotation = Quaternion.Euler(((Quaternion)(ref array2[i])).eulerAngles.x, ((Quaternion)(ref array2[i])).eulerAngles.y, ((Quaternion)(ref array2[i])).eulerAngles.z);
			val2.transform.localScale = array[i];
			switch (i)
			{
			case 9:
				Object.DestroyImmediate((Object)(object)((Component)val2.transform.GetChild(3)).gameObject);
				Object.DestroyImmediate((Object)(object)((Component)val2.transform.GetChild(2)).gameObject);
				Object.DestroyImmediate((Object)(object)val2.GetComponent<HowardFX>());
				Object.DestroyImmediate((Object)(object)val2.GetComponent<HowardAnimator>());
				Object.DestroyImmediate((Object)(object)val2.GetComponent<Animator>());
				((Component)val2.transform.GetChild(0).GetChild(0).GetChild(0)
					.GetChild(0)
					.GetChild(0)
					.GetChild(0)
					.GetChild(0)
					.GetChild(0)
					.GetChild(0)
					.GetChild(0)).gameObject.SetActive(false);
				break;
			case 0:
				val2.SetActive(true);
				break;
			}
		}
		Log("SetupStoredSlotsSpinner Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void LoadTable()
	{
		//IL_0071: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
		Log("LoadTable Started", (bool)((ModSetting)debugging).SavedValue);
		string text = currentScene;
		string text2 = text;
		if (!(text2 == "Gym"))
		{
			if (!(text2 == "Park"))
			{
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(storedTable);
			((Object)val).name = "PokerTable";
			val.transform.position = new Vector3(16.5305f, -20.9391f, -20.8574f);
			val.transform.rotation = Quaternion.Euler(0f, 315.5508f, 0f);
			val.SetActive(true);
			val.gameObject.AddComponent<PhotonView>().ViewID = 8008135;
			tableList.Add(val.AddComponent<Table>());
		}
		else
		{
			GameObject val2 = Object.Instantiate<GameObject>(storedTable);
			((Object)val2).name = "PokerTable";
			val2.transform.position = new Vector3(4.1736f, -3.5255f, -10.3336f);
			val2.transform.rotation = Quaternion.Euler(0f, 170.9995f, 0f);
			val2.SetActive(true);
			val2.gameObject.AddComponent<PhotonView>().ViewID = 8008135;
			tableList.Add(val2.AddComponent<Table>());
			if (flatLandFound)
			{
				((Component)GameObject.Find("/FlatLand/FlatLandButton/").transform.GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
				{
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					foreach (Table table in tableList)
					{
						((Component)table).transform.position = new Vector3(((Component)table).transform.position.x, 0f, ((Component)table).transform.position.z);
					}
				}));
			}
			if (voidLandFound)
			{
				((Component)GameObject.Find("/VoidLand/VoidLandButton/").transform.GetChild(0)).GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit((Action)delegate
				{
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Unknown result type (might be due to invalid IL or missing references)
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					foreach (Table table2 in tableList)
					{
						((Component)table2).transform.position = new Vector3(((Component)table2).transform.position.x, 0f, ((Component)table2).transform.position.z);
					}
				}));
			}
		}
		Log("LoadTable Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	private void LoadSlots()
	{
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0264: Unknown result type (might be due to invalid IL or missing references)
		Log("LoadSlots Started", (bool)((ModSetting)debugging).SavedValue);
		slotsList.Clear();
		if (currentScene != "Gym" && currentScene != "Park")
		{
			return;
		}
		GameObject val = Object.Instantiate<GameObject>(storedSlots);
		string text = currentScene;
		string text2 = text;
		if (!(text2 == "Gym"))
		{
			if (text2 == "Park")
			{
				((Object)val).name = "SlotMachine1";
				val.transform.position = new Vector3(19.4876f, -20.9472f, -17.587f);
				val.transform.rotation = Quaternion.Euler(0f, 320.9668f, 0f);
				val.SetActive(true);
				int num = 8008136;
				PhotonView val2 = val.gameObject.AddComponent<PhotonView>();
				val2.ViewID = num;
				num++;
				slotsList.Add(val.AddComponent<SlotMachine>());
				val = Object.Instantiate<GameObject>(storedSlots);
				((Object)val).name = "SlotMachine2";
				val.transform.position = new Vector3(18.4876f, -20.9472f, -18.387f);
				val.transform.rotation = Quaternion.Euler(0f, 320.9668f, 0f);
				val.SetActive(true);
				val2 = val.gameObject.AddComponent<PhotonView>();
				val2.ViewID = num;
				num++;
				slotsList.Add(val.AddComponent<SlotMachine>());
				val = Object.Instantiate<GameObject>(storedSlots);
				((Object)val).name = "SlotMachine3";
				val.transform.position = new Vector3(17.4876f, -20.9472f, -19.187f);
				val.transform.rotation = Quaternion.Euler(0f, 320.9668f, 0f);
				val.SetActive(true);
				val2 = val.gameObject.AddComponent<PhotonView>();
				val2.ViewID = num;
				num++;
				slotsList.Add(val.AddComponent<SlotMachine>());
			}
		}
		else
		{
			((Object)val).name = "SlotMachine";
			val.transform.position = new Vector3(1.7463f, -3.4255f, -11.8445f);
			val.transform.rotation = Quaternion.Euler(0f, 133.8f, 0f);
			val.SetActive(true);
			val.gameObject.AddComponent<PhotonView>().ViewID = 8008136;
			slotsList.Add(val.AddComponent<SlotMachine>());
		}
		Log("LoadSlots Completed", (bool)((ModSetting)debugging).SavedValue);
	}

	public static int GetPlayerCoinCount()
	{
		return playerCoins;
	}

	public static int Payout(int bet, float multiplyer, Table table)
	{
		float num = bet;
		if (!table.freePlay)
		{
			playerCoins += (int)(num * multiplyer);
		}
		EncryptStringToFile(playerCoins + "|" + posesCompleted, "UserData\\GamblingMod\\Save.save", "UlvakSkillz");
		return (int)(num * multiplyer);
	}

	public static int Payout(int bet, float multiplyer, SlotMachine slotMachine)
	{
		float num = bet;
		if (!slotMachine.freePlay)
		{
			playerCoins += (int)(num * multiplyer);
		}
		EncryptStringToFile(playerCoins + "|" + posesCompleted, "UserData\\GamblingMod\\Save.save", "UlvakSkillz");
		return (int)(num * multiplyer);
	}

	public static int Payout(int bet, float multiplyer)
	{
		float num = bet;
		playerCoins += (int)(num * multiplyer);
		EncryptStringToFile(playerCoins + "|" + posesCompleted, "UserData\\GamblingMod\\Save.save", "UlvakSkillz");
		return (int)(num * multiplyer);
	}

	public static void EncryptStringToFile(string plainText, string filePath, string password)
	{
		byte[] bytes = RandomNumberGenerator.GetBytes(16);
		using Aes aes = Aes.Create();
		aes.KeySize = 256;
		aes.BlockSize = 128;
		aes.Padding = PaddingMode.PKCS7;
		using (Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, bytes, 100000))
		{
			aes.Key = rfc2898DeriveBytes.GetBytes(32);
			aes.IV = rfc2898DeriveBytes.GetBytes(16);
		}
		using FileStream fileStream = new FileStream(filePath, FileMode.Create);
		fileStream.Write(bytes, 0, bytes.Length);
		fileStream.Write(aes.IV, 0, aes.IV.Length);
		using ICryptoTransform transform = aes.CreateEncryptor();
		using CryptoStream stream = new CryptoStream(fileStream, transform, CryptoStreamMode.Write);
		using StreamWriter streamWriter = new StreamWriter(stream);
		streamWriter.Write(plainText);
	}

	public static string DecryptStringFromFile(string filePath, string password)
	{
		byte[] array = new byte[16];
		byte[] array2 = new byte[16];
		using FileStream fileStream = new FileStream(filePath, FileMode.Open);
		fileStream.Read(array, 0, array.Length);
		fileStream.Read(array2, 0, array2.Length);
		using Aes aes = Aes.Create();
		aes.KeySize = 256;
		aes.BlockSize = 128;
		aes.Padding = PaddingMode.PKCS7;
		using (Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, array, 100000))
		{
			aes.Key = rfc2898DeriveBytes.GetBytes(32);
		}
		aes.IV = array2;
		using ICryptoTransform transform = aes.CreateDecryptor();
		using CryptoStream stream = new CryptoStream(fileStream, transform, CryptoStreamMode.Read);
		using StreamReader streamReader = new StreamReader(stream);
		return streamReader.ReadToEnd();
	}
}
[RegisterTypeInIl2Cpp]
public class SlotMachine : MonoBehaviourPun
{
	[CompilerGenerated]
	private sealed class <AnimateTopLight>d__60 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int payout;

		public SlotMachine <>4__this;

		private AudioSource <sound>5__1;

		private int <ticks>5__2;

		private float <currentRotation>5__3;

		private float <currentHeight>5__4;

		private float <heightPerTick>5__5;

		private DateTime <soundDoneTime>5__6;

		private int <i>5__7;

		private int <i>5__8;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <AnimateTopLight>d__60(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<sound>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: 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_01a4: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Expected O, but got Unknown
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("AnimateTopLight Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<sound>5__1 = ((Component)<>4__this.soundsParent.transform.GetChild(4)).gameObject.GetComponent<AudioSource>();
				<>4__this.topLight.transform.localPosition = new Vector3(4.15874f, 74.5f, -6.97464f);
				<>4__this.topLight.transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
				<>4__this.topLight.SetActive(true);
				<ticks>5__2 = 25;
				<currentRotation>5__3 = 0f;
				<currentHeight>5__4 = 74.5f;
				<heightPerTick>5__5 = 7.692f / (float)<ticks>5__2;
				<i>5__7 = 0;
				goto IL_01c5;
			case 1:
				<>1__state = -1;
				<i>5__7++;
				goto IL_01c5;
			case 2:
				<>1__state = -1;
				goto IL_02ab;
			case 3:
				{
					<>1__state = -1;
					<i>5__8++;
					break;
				}
				IL_01c5:
				if (<i>5__7 < <ticks>5__2)
				{
					<currentRotation>5__3 += 5f;
					<currentHeight>5__4 += <heightPerTick>5__5;
					<>4__this.topLight.transform.localPosition = new Vector3(4.15874f, <currentHeight>5__4, -6.97464f);
					<>4__this.topLight.transform.localRotation = Quaternion.Euler(-90f, 0f, <currentRotation>5__3);
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<>4__this.topLight.transform.localPosition = new Vector3(4.15874f, 82.192f, -6.97464f);
				<soundDoneTime>5__6 = DateTime.Now.AddSeconds(((Il2CppArrayBase<WeightedClip>)(object)Main.storedAudioCalls[4].clips)[0].Clip.length * 0.7f * (float)(payout / 100) - 0.5f);
				goto IL_02ab;
				IL_02ab:
				if (DateTime.Now < <soundDoneTime>5__6)
				{
					<currentRotation>5__3 += 5f;
					<>4__this.topLight.transform.localRotation = Quaternion.Euler(-90f, 0f, <currentRotation>5__3);
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 2;
					return true;
				}
				<i>5__8 = 0;
				break;
			}
			if (<i>5__8 < <ticks>5__2)
			{
				<currentRotation>5__3 += 5f;
				<currentHeight>5__4 -= <heightPerTick>5__5;
				<>4__this.topLight.transform.localPosition = new Vector3(4.15874f, <currentHeight>5__4, -6.97464f);
				<>4__this.topLight.transform.localRotation = Quaternion.Euler(-90f, 0f, <currentRotation>5__3);
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 3;
				return true;
			}
			<>4__this.topLight.SetActive(false);
			Log("AnimateTopLight Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <CheckWinPhase>d__58 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public bool isPlaying;

		public SlotMachine <>4__this;

		private int[][] <wheelNumberLineup>5__1;

		private int[] <minusOneNumber>5__2;

		private int[] <plusOneNumber>5__3;

		private int[] <line0>5__4;

		private int[] <line1>5__5;

		private int[] <line2>5__6;

		private TextMeshPro <titleTextMP>5__7;

		private List<object> <showTopWinCoroutines>5__8;

		private int <payout>5__9;

		private bool <hasWon>5__10;

		private int <amount>5__11;

		private string <payoutPart>5__12;

		private string <numbersPart>5__13;

		private int <i>5__14;

		private int[] <crossline>5__15;

		private int[] <crossline2>5__16;

		private string <payoutString>5__17;

		private int <i>5__18;

		private List<object>.Enumerator <>s__19;

		private object <coroutine>5__20;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <CheckWinPhase>d__58(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			int num = <>1__state;
			if (num == -3 || num == 10)
			{
				try
				{
				}
				finally
				{
					<>m__Finally1();
				}
			}
			<wheelNumberLineup>5__1 = null;
			<minusOneNumber>5__2 = null;
			<plusOneNumber>5__3 = null;
			<line0>5__4 = null;
			<line1>5__5 = null;
			<line2>5__6 = null;
			<titleTextMP>5__7 = null;
			<showTopWinCoroutines>5__8 = null;
			<payoutPart>5__12 = null;
			<numbersPart>5__13 = null;
			<crossline>5__15 = null;
			<crossline2>5__16 = null;
			<payoutString>5__17 = null;
			<>s__19 = default(List<object>.Enumerator);
			<coroutine>5__20 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_1059: Unknown result type (might be due to invalid IL or missing references)
			//IL_1063: Expected O, but got Unknown
			//IL_112b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1135: Expected O, but got Unknown
			//IL_0f7e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f88: Expected O, but got Unknown
			//IL_0bc9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd3: Expected O, but got Unknown
			//IL_0edf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ee9: Expected O, but got Unknown
			//IL_0a71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7b: Expected O, but got Unknown
			//IL_0d95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9f: Expected O, but got Unknown
			//IL_0908: Unknown result type (might be due to invalid IL or missing references)
			//IL_0912: Expected O, but got Unknown
			try
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log("CheckWinPhase Started", (bool)((ModSetting)Main.debugging).SavedValue);
					<>4__this.playingWheelSpinSound = false;
					<wheelNumberLineup>5__1 = new int[3][];
					<minusOneNumber>5__2 = new int[3]
					{
						<>4__this.wheelsNumber[0] - 1,
						<>4__this.wheelsNumber[1] - 1,
						<>4__this.wheelsNumber[2] - 1
					};
					<plusOneNumber>5__3 = new int[3]
					{
						<>4__this.wheelsNumber[0] + 1,
						<>4__this.wheelsNumber[1] + 1,
						<>4__this.wheelsNumber[2] + 1
					};
					if (<minusOneNumber>5__2[0] < 0)
					{
						<minusOneNumber>5__2[0] += 10;
					}
					if (<minusOneNumber>5__2[1] < 0)
					{
						<minusOneNumber>5__2[1] += 10;
					}
					if (<minusOneNumber>5__2[2] < 0)
					{
						<minusOneNumber>5__2[2] += 10;
					}
					if (<plusOneNumber>5__3[0] > 9)
					{
						<plusOneNumber>5__3[0] -= 10;
					}
					if (<plusOneNumber>5__3[1] > 9)
					{
						<plusOneNumber>5__3[1] -= 10;
					}
					if (<plusOneNumber>5__3[2] > 9)
					{
						<plusOneNumber>5__3[2] -= 10;
					}
					<line0>5__4 = new int[3]
					{
						<>4__this.slotsOrder[0][<minusOneNumber>5__2[0]],
						<>4__this.slotsOrder[1][<minusOneNumber>5__2[1]],
						<>4__this.slotsOrder[2][<minusOneNumber>5__2[2]]
					};
					<line1>5__5 = new int[3]
					{
						<>4__this.slotsOrder[0][<>4__this.wheelsNumber[0]],
						<>4__this.slotsOrder[1][<>4__this.wheelsNumber[1]],
						<>4__this.slotsOrder[2][<>4__this.wheelsNumber[2]]
					};
					<line2>5__6 = new int[3]
					{
						<>4__this.slotsOrder[0][<plusOneNumber>5__3[0]],
						<>4__this.slotsOrder[1][<plusOneNumber>5__3[1]],
						<>4__this.slotsOrder[2][<plusOneNumber>5__3[2]]
					};
					<wheelNumberLineup>5__1[0] = <line0>5__4;
					<wheelNumberLineup>5__1[1] = <line1>5__5;
					<wheelNumberLineup>5__1[2] = <line2>5__6;
					<i>5__14 = 0;
					while (<i>5__14 < 3)
					{
						Log($"Slot {<i>5__14}: {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][0]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][1]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][2]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][3]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][4]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][5]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][6]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][7]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][8]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__14][9]]}", (bool)((ModSetting)Main.debugging).SavedValue);
						<i>5__14++;
					}
					Log($"Wheel : {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[2][0]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[2][1]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[2][2]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					Log($"Wheel : {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[1][0]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[1][1]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[1][2]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					Log($"Wheel : {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[0][0]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[0][1]]} {<>4__this.SlotsSpotTypesString[<wheelNumberLineup>5__1[0][2]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					<titleTextMP>5__7 = <>4__this.slotMachineTitleText.GetComponent<TextMeshPro>();
					((TMP_Text)<titleTextMP>5__7).text = "Payout: ";
					<showTopWinCoroutines>5__8 = new List<object>();
					<payout>5__9 = 0;
					<hasWon>5__10 = false;
					<>4__this.stopWinAnimation = false;
					Log("Checking Middle Line", (bool)((ModSetting)Main.debugging).SavedValue);
					<amount>5__11 = <>4__this.CheckWinLine(<wheelNumberLineup>5__1[1]);
					if (<amount>5__11 != 0)
					{
						if (<hasWon>5__10)
						{
							TextMeshPro obj = <titleTextMP>5__7;
							((TMP_Text)obj).text = ((TMP_Text)obj).text + " + ";
						}
						else
						{
							<hasWon>5__10 = true;
						}
						TextMeshPro obj2 = <titleTextMP>5__7;
						((TMP_Text)obj2).text = ((TMP_Text)obj2).text + <amount>5__11;
						MelonCoroutines.Start(<>4__this.FlashColors(<>4__this.betLines[0]));
						<showTopWinCoroutines>5__8.Add(MelonCoroutines.Start(<>4__this.DisplayWinOnTop(<wheelNumberLineup>5__1[1])));
						<>4__this.PlayPayoutSound();
						<>2__current = (object)new WaitForSeconds(1.75f);
						<>1__state = 1;
						return true;
					}
					goto IL_0928;
				case 1:
					<>1__state = -1;
					goto IL_0928;
				case 2:
					<>1__state = -1;
					goto IL_0a91;
				case 3:
					<>1__state = -1;
					goto IL_0be9;
				case 4:
					<>1__state = -1;
					goto IL_0db5;
				case 5:
					<>1__state = -1;
					goto IL_0eff;
				case 6:
					<>1__state = -1;
					<payoutPart>5__12 = "Payout: ";
					<numbersPart>5__13 = ((TMP_Text)<titleTextMP>5__7).text.Substring(8, ((TMP_Text)<titleTextMP>5__7).text.Length - 8);
					if (<numbersPart>5__13.Contains("+"))
					{
						Log("Animating Payout Text", (bool)((ModSetting)Main.debugging).SavedValue);
						goto IL_1079;
					}
					goto IL_117a;
				case 7:
					<>1__state = -1;
					goto IL_1079;
				case 8:
					<>1__state = -1;
					<i>5__18--;
					goto IL_115d;
				case 9:
					<>1__state = -1;
					goto IL_12c3;
				case 10:
					{
						<>1__state = -3;
						<coroutine>5__20 = null;
						break;
					}
					IL_12c3:
					<>s__19 = <showTopWinCoroutines>5__8.GetEnumerator();
					<>1__state = -3;
					break;
					IL_1079:
					if (<numbersPart>5__13.Length > 0)
					{
						<numbersPart>5__13 = <numbersPart>5__13.Remove(<>4__this.random.Next(0, <numbersPart>5__13.Length), 1);
						((TMP_Text)<titleTextMP>5__7).text = <payoutPart>5__12 + <numbersPart>5__13;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 7;
						return true;
					}
					<numbersPart>5__13 = "";
					((TMP_Text)<titleTextMP>5__7).text = <payoutPart>5__12 + <numbersPart>5__13;
					<payoutString>5__17 = <payout>5__9.ToString();
					<i>5__18 = <payoutString>5__17.Length - 1;
					goto IL_115d;
					IL_115d:
					if (<i>5__18 >= 0)
					{
						<numbersPart>5__13 = <payoutString>5__17.Substring(<i>5__18, <payoutString>5__17.Length - <i>5__18);
						((TMP_Text)<titleTextMP>5__7).text = <payoutPart>5__12 + <numbersPart>5__13;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 8;
						return true;
					}
					<payoutString>5__17 = null;
					goto IL_117a;
					IL_117a:
					if (<payout>5__9 > 0)
					{
						Log("Paying Out: (FreePlay: " + (<>4__this.freePlay ? "Yes" : "No") + ") " + <payout>5__9);
					}
					if (!<>4__this.freePlay & isPlaying)
					{
						<>4__this.amountGotOut += <payout>5__9;
						Main.Payout(<payout>5__9, 1f, <>4__this);
						((TMP_Text)<>4__this.coinsOut.GetComponent<TextMeshPro>()).text = "Out: " + <>4__this.amountGotOut;
					}
					if (<payout>5__9 == 0)
					{
						<>4__this.PlayNoPayoutSound();
					}
					else if (<payout>5__9 >= 100)
					{
						MelonCoroutines.Start(<>4__this.AnimateTopLight(<payout>5__9));
						<>2__current = MelonCoroutines.Start(<>4__this.PlayBigPayoutSound(<payout>5__9));
						<>1__state = 9;
						return true;
					}
					goto IL_12c3;
					IL_0db5:
					Log("Payout: " + <amount>5__11, (bool)((ModSetting)Main.debugging).SavedValue);
					<payout>5__9 += <amount>5__11;
					Log("Checking Bottom Left to Top Right Line", (bool)((ModSetting)Main.debugging).SavedValue);
					<amount>5__11 = <>4__this.CheckWinLine(<crossline>5__15);
					if (<amount>5__11 != 0)
					{
						if (<hasWon>5__10)
						{
							TextMeshPro obj3 = <titleTextMP>5__7;
							((TMP_Text)obj3).text = ((TMP_Text)obj3).text + " + ";
						}
						else
						{
							<hasWon>5__10 = true;
						}
						TextMeshPro obj4 = <titleTextMP>5__7;
						((TMP_Text)obj4).text = ((TMP_Text)obj4).text + <amount>5__11;
						MelonCoroutines.Start(<>4__this.FlashColors(<>4__this.betLines[4]));
						<showTopWinCoroutines>5__8.Add(MelonCoroutines.Start(<>4__this.DisplayWinOnTop(<crossline>5__15)));
						<>4__this.PlayPayoutSound();
						<>2__current = (object)new WaitForSeconds(1.75f);
						<>1__state = 5;
						return true;
					}
					goto IL_0eff;
					IL_0928:
					Log("Payout: " + <amount>5__11, (bool)((ModSetting)Main.debugging).SavedValue);
					<payout>5__9 += <amount>5__11;
					if (<>4__this.betAmount >= 3)
					{
						Log("Checking Bottom Line", (bool)((ModSetting)Main.debugging).SavedValue);
						<amount>5__11 = <>4__this.CheckWinLine(<wheelNumberLineup>5__1[0]);
						if (<amount>5__11 != 0)
						{
							if (<hasWon>5__10)
							{
								TextMeshPro obj5 = <titleTextMP>5__7;
								((TMP_Text)obj5).text = ((TMP_Text)obj5).text + " + ";
							}
							else
							{
								<hasWon>5__10 = true;
							}
							TextMeshPro obj6 = <titleTextMP>5__7;
							((TMP_Text)obj6).text = ((TMP_Text)obj6).text + <amount>5__11;
							MelonCoroutines.Start(<>4__this.FlashColors(<>4__this.betLines[1]));
							<showTopWinCoroutines>5__8.Add(MelonCoroutines.Start(<>4__this.DisplayWinOnTop(<wheelNumberLineup>5__1[0])));
							<>4__this.PlayPayoutSound();
							<>2__current = (object)new WaitForSeconds(1.75f);
							<>1__state = 2;
							return true;
						}
						goto IL_0a91;
					}
					goto IL_0c27;
					IL_0eff:
					Log("Payout: " + <amount>5__11, (bool)((ModSetting)Main.debugging).SavedValue);
					<payout>5__9 += <amount>5__11;
					<crossline>5__15 = null;
					<crossline2>5__16 = null;
					goto IL_0f4b;
					IL_0be9:
					Log("Payout: " + <amount>5__11, (bool)((ModSetting)Main.debugging).SavedValue);
					<payout>5__9 += <amount>5__11;
					goto IL_0c27;
					IL_0f4b:
					if (<payout>5__9 == 0)
					{
						TextMeshPro obj7 = <titleTextMP>5__7;
						((TMP_Text)obj7).text = ((TMP_Text)obj7).text + "0";
					}
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 6;
					return true;
					IL_0a91:
					Log("Payout: " + <amount>5__11, (bool)((ModSetting)Main.debugging).SavedValue);
					<payout>5__9 += <amount>5__11;
					Log("Checking Top Line", (bool)((ModSetting)Main.debugging).SavedValue);
					<amount>5__11 = <>4__this.CheckWinLine(<wheelNumberLineup>5__1[2]);
					if (<amount>5__11 != 0)
					{
						if (<hasWon>5__10)
						{
							TextMeshPro obj8 = <titleTextMP>5__7;
							((TMP_Text)obj8).text = ((TMP_Text)obj8).text + " + ";
						}
						else
						{
							<hasWon>5__10 = true;
						}
						TextMeshPro component = <>4__this.slotMachineTitleText.GetComponent<TextMeshPro>();
						((TMP_Text)component).text = ((TMP_Text)component).text + <amount>5__11;
						MelonCoroutines.Start(<>4__this.FlashColors(<>4__this.betLines[2]));
						<showTopWinCoroutines>5__8.Add(MelonCoroutines.Start(<>4__this.DisplayWinOnTop(<wheelNumberLineup>5__1[2])));
						<>4__this.PlayPayoutSound();
						<>2__current = (object)new WaitForSeconds(1.75f);
						<>1__state = 3;
						return true;
					}
					goto IL_0be9;
					IL_0c27:
					if (<>4__this.betAmount >= 5)
					{
						<crossline>5__15 = new int[3]
						{
							<wheelNumberLineup>5__1[0][0],
							<wheelNumberLineup>5__1[1][1],
							<wheelNumberLineup>5__1[2][2]
						};
						<crossline2>5__16 = new int[3]
						{
							<wheelNumberLineup>5__1[0][2],
							<wheelNumberLineup>5__1[1][1],
							<wheelNumberLineup>5__1[2][0]
						};
						Log("Checking Top Left to Bottom Right Line", (bool)((ModSetting)Main.debugging).SavedValue);
						<amount>5__11 = <>4__this.CheckWinLine(<crossline2>5__16);
						if (<amount>5__11 != 0)
						{
							if (<hasWon>5__10)
							{
								TextMeshPro obj9 = <titleTextMP>5__7;
								((TMP_Text)obj9).text = ((TMP_Text)obj9).text + " + ";
							}
							else
							{
								<hasWon>5__10 = true;
							}
							TextMeshPro obj10 = <titleTextMP>5__7;
							((TMP_Text)obj10).text = ((TMP_Text)obj10).text + <amount>5__11;
							MelonCoroutines.Start(<>4__this.FlashColors(<>4__this.betLines[3]));
							<showTopWinCoroutines>5__8.Add(MelonCoroutines.Start(<>4__this.DisplayWinOnTop(<crossline2>5__16)));
							<>4__this.PlayPayoutSound();
							<>2__current = (object)new WaitForSeconds(1.75f);
							<>1__state = 4;
							return true;
						}
						goto IL_0db5;
					}
					goto IL_0f4b;
				}
				if (<>s__19.MoveNext())
				{
					<coroutine>5__20 = <>s__19.Current;
					<>2__current = <coroutine>5__20;
					<>1__state = 10;
					return true;
				}
				<>m__Finally1();
				<>s__19 = default(List<object>.Enumerator);
				<>4__this.spinning = false;
				Log("CheckWinPhase Completed", (bool)((ModSetting)Main.debugging).SavedValue);
				return false;
			}
			catch
			{
				//try-fault
				((IDisposable)this).Dispose();
				throw;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void <>m__Finally1()
		{
			<>1__state = -1;
			((IDisposable)<>s__19).Dispose();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DisplayWinOnTop>d__63 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int[] line;

		public SlotMachine <>4__this;

		private GameObject[] <slotObjects>5__1;

		private GameObject[] <slotObjectsParents>5__2;

		private float[] <positions>5__3;

		private float <distancePerTick>5__4;

		private float <rotationPerTick>5__5;

		private float <currentScale>5__6;

		private int <i>5__7;

		private int <i>5__8;

		private int <j>5__9;

		private GameObject[] <>s__10;

		private int <>s__11;

		private GameObject <slotObject>5__12;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DisplayWinOnTop>d__63(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<slotObjects>5__1 = null;
			<slotObjectsParents>5__2 = null;
			<positions>5__3 = null;
			<>s__10 = null;
			<slotObject>5__12 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Expected O, but got Unknown
			//IL_058f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_0649: Unknown result type (might be due to invalid IL or missing references)
			//IL_064d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0670: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0709: Unknown result type (might be due to invalid IL or missing references)
			//IL_0713: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log($"DisplayWinOnTop({line[0]} {line[1]} {line[2]}) Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<slotObjects>5__1 = (GameObject[])(object)new GameObject[line.Length];
				<slotObjectsParents>5__2 = (GameObject[])(object)new GameObject[line.Length];
				<positions>5__3 = new float[3] { 0.33f, 0.12f, -0.14f };
				<i>5__7 = 0;
				while (<i>5__7 < line.Length)
				{
					<slotObjectsParents>5__2[<i>5__7] = new GameObject("SlotObjectPosition" + <i>5__7);
					<slotObjectsParents>5__2[<i>5__7].transform.SetParent(<>4__this.activeObjects.transform);
					<slotObjectsParents>5__2[<i>5__7].transform.localPosition = new Vector3(<positions>5__3[<i>5__7], 1.5f, 0.1f);
					<slotObjectsParents>5__2[<i>5__7].transform.localRotation = Quaternion.identity;
					<slotObjectsParents>5__2[<i>5__7].transform.localScale = Vector3.one;
					<slotObjects>5__1[<i>5__7] = Object.Instantiate<GameObject>(<>4__this.slotObjectOriginals[line[<i>5__7]]);
					((Object)<slotObjects>5__1[<i>5__7]).name = <>4__this.SlotsSpotTypesString[line[<i>5__7]];
					<slotObjects>5__1[<i>5__7].transform.SetParent(<slotObjectsParents>5__2[<i>5__7].transform);
					<slotObjects>5__1[<i>5__7].transform.localPosition = Vector3.zero;
					if (line[<i>5__7] == 0)
					{
						<slotObjects>5__1[<i>5__7].transform.localRotation = Quaternion.Euler(0f, 270f, 0f);
						<slotObjects>5__1[<i>5__7].transform.localScale = new Vector3(0.015f, 0.015f, 0.015f);
					}
					else if (line[<i>5__7] == 9)
					{
						<slotObjects>5__1[<i>5__7].transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
						<slotObjects>5__1[<i>5__7].transform.localScale = new Vector3(0.09f, 0.08f, 0.09f);
						<slotObjects>5__1[<i>5__7].transform.GetChild(0).localPosition = new Vector3(-0.021f, -0.905f, 0f);
					}
					else
					{
						<slotObjects>5__1[<i>5__7].transform.localRotation = Quaternion.Euler(0f, 90f, 0f);
						<slotObjects>5__1[<i>5__7].transform.localScale = new Vector3(2f, 2f, 2f);
						if (line[<i>5__7] == 1)
						{
							<slotObjects>5__1[<i>5__7].transform.localPosition = new Vector3(0f, 0.03f, -0.05f);
						}
						else if (line[<i>5__7] == 2)
						{
							<slotObjects>5__1[<i>5__7].transform.localPosition = new Vector3(0f, 0.04f, 0f);
							<slotObjects>5__1[<i>5__7].transform.localRotation = Quaternion.Euler(0f, 0f, 90f);
						}
						else
						{
							<slotObjects>5__1[<i>5__7].transform.localPosition = new Vector3(0f, 0f, -0.05f);
						}
					}
					<slotObjects>5__1[<i>5__7].transform.GetChild(0).localScale = new Vector3(1f, 1f, 1f);
					<i>5__7++;
				}
				<distancePerTick>5__4 = 0.006f;
				<rotationPerTick>5__5 = 10f;
				<currentScale>5__6 = 1f;
				<i>5__8 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__8++;
				break;
			}
			if (<i>5__8 < 125)
			{
				<j>5__9 = 0;
				while (<j>5__9 < <slotObjectsParents>5__2.Length)
				{
					if (<i>5__8 < 25 || <i>5__8 >= 100)
					{
						<slotObjectsParents>5__2[<j>5__9].transform.localPosition = new Vector3(<slotObjectsParents>5__2[<j>5__9].transform.localPosition.x, <slotObjectsParents>5__2[<j>5__9].transform.localPosition.y + <distancePerTick>5__4, <slotObjectsParents>5__2[<j>5__9].transform.localPosition.z);
					}
					if (<i>5__8 >= 25)
					{
						Transform transform = <slotObjectsParents>5__2[<j>5__9].transform;
						Quaternion localRotation = <slotObjectsParents>5__2[<j>5__9].transform.localRotation;
						float x = ((Quaternion)(ref localRotation)).eulerAngles.x;
						localRotation = <slotObjectsParents>5__2[<j>5__9].transform.localRotation;
						float num = ((Quaternion)(ref localRotation)).eulerAngles.y - <rotationPerTick>5__5;
						localRotation = <slotObjectsParents>5__2[<j>5__9].transform.localRotation;
						transform.localRotation = Quaternion.Euler(x, num, ((Quaternion)(ref localRotation)).eulerAngles.z);
					}
					if (<i>5__8 >= 100)
					{
						<slotObjectsParents>5__2[<j>5__9].transform.localPosition = new Vector3(<slotObjectsParents>5__2[<j>5__9].transform.localPosition.x, <slotObjectsParents>5__2[<j>5__9].transform.localPosition.y + <distancePerTick>5__4, <slotObjectsParents>5__2[<j>5__9].transform.localPosition.z);
						<currentScale>5__6 = (float)(124 - <i>5__8) / 25f;
						<slotObjectsParents>5__2[<j>5__9].transform.localScale = new Vector3(<currentScale>5__6, <currentScale>5__6, <currentScale>5__6);
					}
					<j>5__9++;
				}
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 1;
				return true;
			}
			<>s__10 = <slotObjectsParents>5__2;
			for (<>s__11 = 0; <>s__11 < <>s__10.Length; <>s__11++)
			{
				<slotObject>5__12 = <>s__10[<>s__11];
				Object.Destroy((Object)(object)<slotObject>5__12);
				<slotObject>5__12 = null;
			}
			<>s__10 = null;
			Log("DisplayWinOnTop(" + line.ToString() + ") Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <FlashColors>d__64 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject betLine;

		public SlotMachine <>4__this;

		private MeshRenderer[] <meshes>5__1;

		private float <r>5__2;

		private float <g>5__3;

		private float <b>5__4;

		private int <currentDirectionR>5__5;

		private int <currentDirectionG>5__6;

		private int <currentDirectionB>5__7;

		private bool[] <directionIsMoving>5__8;

		private int <i>5__9;

		private int <j>5__10;

		private int <i>5__11;

		private int <i>5__12;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <FlashColors>d__64(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<meshes>5__1 = null;
			<directionIsMoving>5__8 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
				if (<>4__this.stopWinAnimation)
				{
					goto IL_023c;
				}
				<j>5__10++;
				goto IL_022a;
			}
			<>1__state = -1;
			<meshes>5__1 = (MeshRenderer[])(object)new MeshRenderer[betLine.transform.GetChildCount()];
			<i>5__9 = 0;
			while (<i>5__9 < betLine.transform.GetChildCount())
			{
				<meshes>5__1[<i>5__9] = ((Component)betLine.transform.GetChild(<i>5__9)).GetComponent<MeshRenderer>();
				<i>5__9++;
			}
			<r>5__2 = 0f;
			<g>5__3 = 0f;
			<b>5__4 = 1f;
			<currentDirectionR>5__5 = 1;
			<currentDirectionG>5__6 = 1;
			<currentDirectionB>5__7 = -1;
			<directionIsMoving>5__8 = new bool[3] { false, true, false };
			goto IL_02cb;
			IL_02cb:
			if (!<>4__this.stopWinAnimation)
			{
				<j>5__10 = 0;
				goto IL_022a;
			}
			<i>5__12 = 0;
			while (<i>5__12 < <meshes>5__1.Length)
			{
				((Renderer)<meshes>5__1[<i>5__12]).material.color = new Color(0.6667f, 0.6667f, 0.6314f);
				<i>5__12++;
			}
			return false;
			IL_022a:
			if (<j>5__10 < 5)
			{
				try
				{
					if (<directionIsMoving>5__8[0])
					{
						<r>5__2 += (float)<currentDirectionR>5__5 * 0.2f;
					}
					else if (<directionIsMoving>5__8[1])
					{
						<g>5__3 += (float)<currentDirectionG>5__6 * 0.2f;
					}
					else if (<directionIsMoving>5__8[2])
					{
						<b>5__4 += (float)<currentDirectionB>5__7 * 0.2f;
					}
					<i>5__11 = 0;
					while (<i>5__11 < <meshes>5__1.Length)
					{
						((Renderer)<meshes>5__1[<i>5__11]).material.color = new Color(<r>5__2, <g>5__3, <b>5__4);
						<i>5__11++;
					}
				}
				catch
				{
					return false;
				}
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}
			goto IL_023c;
			IL_023c:
			if (<directionIsMoving>5__8[0])
			{
				<directionIsMoving>5__8 = new bool[3] { false, true, false };
				<currentDirectionR>5__5 *= -1;
			}
			else if (<directionIsMoving>5__8[1])
			{
				<directionIsMoving>5__8 = new bool[3] { false, false, true };
				<currentDirectionG>5__6 *= -1;
			}
			else if (<directionIsMoving>5__8[2])
			{
				<directionIsMoving>5__8 = new bool[3] { true, false, false };
				<currentDirectionB>5__7 *= -1;
			}
			goto IL_02cb;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayBigPayoutSound>d__62 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int payout;

		public SlotMachine <>4__this;

		private PooledAudioSource <pooledAudio>5__1;

		private int <i>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayBigPayoutSound>d__62(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<pooledAudio>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log($"PlayBigPayoutSound({payout}) Called", (bool)((ModSetting)Main.debugging).SavedValue);
				<i>5__2 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__2++;
				break;
			}
			if (<i>5__2 < payout / 100)
			{
				<pooledAudio>5__1 = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[4], <>4__this.soundsParent.transform.GetChild(4).position, false);
				<>2__current = (object)new WaitForSeconds(<pooledAudio>5__1.audioSource.clip.length * 0.7f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayShiftStoneSound>d__66 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotMachine <>4__this;

		private PooledAudioSource <pooledAudio>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayShiftStoneSound>d__66(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<pooledAudio>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("PlayShiftStoneSound Called", (bool)((ModSetting)Main.debugging).SavedValue);
				<pooledAudio>5__1 = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[6], <>4__this.soundsParent.transform.GetChild(3).position, false);
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<pooledAudio>5__1 = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[6], <>4__this.soundsParent.transform.GetChild(3).position, false);
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<pooledAudio>5__1 = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[6], <>4__this.soundsParent.transform.GetChild(3).position, false);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlaySpin>d__56 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotMachine <>4__this;

		private int <i>5__1;

		private bool <extraSpins>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlaySpin>d__56(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("Spinning Wheels", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.spinning = true;
				<>2__current = MelonCoroutines.Start(<>4__this.RandomizeSlots());
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				MelonCoroutines.Start(<>4__this.StartWheelSpinSound());
				((TMP_Text)<>4__this.slotMachineTitleText.GetComponent<TextMeshPro>()).text = "Spinning Wheels";
				<i>5__1 = 0;
				while (<i>5__1 < 3)
				{
					<extraSpins>5__2 = false;
					if (<i>5__1 == 3 && <>4__this.random.Next(0, 25) == 0)
					{
						<extraSpins>5__2 = true;
					}
					<>4__this.spinCoroutines[<i>5__1] = MelonCoroutines.Start(<>4__this.SpinNumber(((Component)<>4__this.rotatingWheels.transform.GetChild(<i>5__1)).GetComponent<RevolvingNumber>(), <i>5__1, <extraSpins>5__2));
					<i>5__1++;
				}
				<>2__current = <>4__this.spinCoroutines[0];
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				Log("Wheel 1 Done: " + <>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[0][<>4__this.wheelsNumber[0]]], (bool)((ModSetting)Main.debugging).SavedValue);
				((MonoBehaviourPun)<>4__this).photonView.RPC("RPC_RotateToNumber", (RpcTarget)1, (Object[])(object)new Object[2]
				{
					Object.op_Implicit(0),
					Object.op_Implicit(<>4__this.wheelsNumber[0])
				});
				<>2__current = <>4__this.spinCoroutines[1];
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				Log("Wheel 2 Done: " + <>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[1][<>4__this.wheelsNumber[1]]], (bool)((ModSetting)Main.debugging).SavedValue);
				((MonoBehaviourPun)<>4__this).photonView.RPC("RPC_RotateToNumber", (RpcTarget)1, (Object[])(object)new Object[2]
				{
					Object.op_Implicit(1),
					Object.op_Implicit(<>4__this.wheelsNumber[1])
				});
				<>2__current = <>4__this.spinCoroutines[2];
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				Log("Wheel 3 Done: " + <>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[2][<>4__this.wheelsNumber[2]]], (bool)((ModSetting)Main.debugging).SavedValue);
				((MonoBehaviourPun)<>4__this).photonView.RPC("RPC_RotateToNumber", (RpcTarget)1, (Object[])(object)new Object[2]
				{
					Object.op_Implicit(2),
					Object.op_Implicit(<>4__this.wheelsNumber[2])
				});
				<>2__current = MelonCoroutines.Start(<>4__this.CheckWinPhase());
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <PlayWheelSpinSoundTillStopped>d__50 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotMachine <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PlayWheelSpinSoundTillStopped>d__50(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("PlayWheelSpinSoundTillStopped Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.continueWheelSpinSound = true;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.continueWheelSpinSound)
			{
				<>4__this.playingAudio = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[0], <>4__this.soundsParent.transform.GetChild(0).position, false);
				<>2__current = (object)new WaitForSeconds(<>4__this.playingAudio.audioSource.clip.length);
				<>1__state = 1;
				return true;
			}
			Log("PlayWheelSpinSoundTillStopped Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RandomizeSlots>d__71 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotMachine <>4__this;

		private Transform <screen>5__1;

		private float <movementPerTick>5__2;

		private float <currentRotation>5__3;

		private int <i>5__4;

		private int <temp>5__5;

		private int <j>5__6;

		private int <j>5__7;

		private int <randomSpot>5__8;

		private int <i>5__9;

		private int <i>5__10;

		private int <j>5__11;

		private int <i>5__12;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RandomizeSlots>d__71(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<screen>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_059b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Expected O, but got Unknown
			//IL_0647: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abf: Expected O, but got Unknown
			//IL_0a62: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0751: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation;
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("RandomizeSlots Started", (bool)((ModSetting)Main.debugging).SavedValue);
				<i>5__4 = 0;
				while (<i>5__4 < 3)
				{
					<>4__this.slotsOrder[<i>5__4] = new int[10];
					<j>5__6 = 0;
					while (<j>5__6 < 10)
					{
						<>4__this.slotsOrder[<i>5__4][<j>5__6] = <j>5__6;
						<j>5__6++;
					}
					<j>5__7 = 0;
					while (<j>5__7 < 10)
					{
						for (<randomSpot>5__8 = <>4__this.random.Next(0, 10); <randomSpot>5__8 == <j>5__7; <randomSpot>5__8 = <>4__this.random.Next(0, 10))
						{
						}
						<temp>5__5 = <>4__this.slotsOrder[<i>5__4][<j>5__7];
						<>4__this.slotsOrder[<i>5__4][<j>5__7] = <>4__this.slotsOrder[<i>5__4][<randomSpot>5__8];
						<>4__this.slotsOrder[<i>5__4][<randomSpot>5__8] = <temp>5__5;
						Log($"Slot {<i>5__4}: Spots Flipped: {<j>5__7} <-> {<randomSpot>5__8}", (bool)((ModSetting)Main.debugging).SavedValue);
						<j>5__7++;
					}
					<i>5__4++;
				}
				((MonoBehaviourPun)<>4__this).photonView.RPC("RPC_RandomizeSlots", (RpcTarget)1, (Object[])(object)new Object[32]
				{
					Object.op_Implicit(<>4__this.freePlay),
					Object.op_Implicit(<>4__this.betAmount),
					Object.op_Implicit(<>4__this.slotsOrder[0][0]),
					Object.op_Implicit(<>4__this.slotsOrder[0][1]),
					Object.op_Implicit(<>4__this.slotsOrder[0][2]),
					Object.op_Implicit(<>4__this.slotsOrder[0][3]),
					Object.op_Implicit(<>4__this.slotsOrder[0][4]),
					Object.op_Implicit(<>4__this.slotsOrder[0][5]),
					Object.op_Implicit(<>4__this.slotsOrder[0][6]),
					Object.op_Implicit(<>4__this.slotsOrder[0][7]),
					Object.op_Implicit(<>4__this.slotsOrder[0][8]),
					Object.op_Implicit(<>4__this.slotsOrder[0][9]),
					Object.op_Implicit(<>4__this.slotsOrder[1][0]),
					Object.op_Implicit(<>4__this.slotsOrder[1][1]),
					Object.op_Implicit(<>4__this.slotsOrder[1][2]),
					Object.op_Implicit(<>4__this.slotsOrder[1][3]),
					Object.op_Implicit(<>4__this.slotsOrder[1][4]),
					Object.op_Implicit(<>4__this.slotsOrder[1][5]),
					Object.op_Implicit(<>4__this.slotsOrder[1][6]),
					Object.op_Implicit(<>4__this.slotsOrder[1][7]),
					Object.op_Implicit(<>4__this.slotsOrder[1][8]),
					Object.op_Implicit(<>4__this.slotsOrder[1][9]),
					Object.op_Implicit(<>4__this.slotsOrder[2][0]),
					Object.op_Implicit(<>4__this.slotsOrder[2][1]),
					Object.op_Implicit(<>4__this.slotsOrder[2][2]),
					Object.op_Implicit(<>4__this.slotsOrder[2][3]),
					Object.op_Implicit(<>4__this.slotsOrder[2][4]),
					Object.op_Implicit(<>4__this.slotsOrder[2][5]),
					Object.op_Implicit(<>4__this.slotsOrder[2][6]),
					Object.op_Implicit(<>4__this.slotsOrder[2][7]),
					Object.op_Implicit(<>4__this.slotsOrder[2][8]),
					Object.op_Implicit(<>4__this.slotsOrder[2][9])
				});
				((TMP_Text)<>4__this.slotMachineTitleText.GetComponent<TextMeshPro>()).text = "Randomizing";
				<screen>5__1 = ((Component)<>4__this.instance).transform.GetChild(0).GetChild(3);
				<movementPerTick>5__2 = 0.00053333334f;
				localRotation = <screen>5__1.localRotation;
				<currentRotation>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				<i>5__9 = 0;
				goto IL_067f;
			case 1:
				<>1__state = -1;
				<i>5__9++;
				goto IL_067f;
			case 2:
				{
					<>1__state = -1;
					<i>5__12++;
					break;
				}
				IL_067f:
				if (<i>5__9 < 75)
				{
					<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, <>4__this.rotatingWheels.transform.localPosition.z - <movementPerTick>5__2);
					if (<i>5__9 >= 25)
					{
						<currentRotation>5__3 += 3.6f;
						((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, <currentRotation>5__3);
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, -0.023f);
				((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, 90f);
				<i>5__10 = 0;
				while (<i>5__10 < 3)
				{
					<j>5__11 = 0;
					while (<j>5__11 < 10)
					{
						<>4__this.rotatingWheels.transform.GetChild(<i>5__10).GetChild(0).GetChild(<>4__this.slotsOrder[<i>5__10][<j>5__11])
							.localRotation = Quaternion.Euler(0f, 0f, 270f - (float)(<j>5__11 * 36));
						<j>5__11++;
					}
					Log($"Finished Slot {<i>5__10}: {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][0]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][1]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][2]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][3]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][4]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][5]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][6]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][7]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][8]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__10][9]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					<i>5__10++;
				}
				localRotation = <screen>5__1.localRotation;
				<currentRotation>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				<i>5__12 = 0;
				break;
			}
			if (<i>5__12 < 75)
			{
				if (<i>5__12 < 50)
				{
					<currentRotation>5__3 += 3.6f;
					((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, <currentRotation>5__3);
				}
				<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, <>4__this.rotatingWheels.transform.localPosition.z + <movementPerTick>5__2);
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, 0.017f);
			((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, 270f);
			Log("RandomizeSlots Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RandomizeSlots>d__73 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int[] newSlotsOrder;

		public SlotMachine <>4__this;

		private Transform <screen>5__1;

		private float <movementPerTick>5__2;

		private float <currentRotation>5__3;

		private int <i>5__4;

		private int <i>5__5;

		private int <j>5__6;

		private int <j>5__7;

		private int <i>5__8;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RandomizeSlots>d__73(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<screen>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0743: Unknown result type (might be due to invalid IL or missing references)
			//IL_0768: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Expected O, but got Unknown
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_0631: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation;
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log("RandomizeSlots(int[]) Started", (bool)((ModSetting)Main.debugging).SavedValue);
				((TMP_Text)<>4__this.slotMachineTitleText.GetComponent<TextMeshPro>()).text = "Randomizing";
				<screen>5__1 = ((Component)<>4__this.instance).transform.GetChild(0).GetChild(3);
				<movementPerTick>5__2 = 0.00053333334f;
				localRotation = <screen>5__1.localRotation;
				<currentRotation>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				Log("RandomizeSlots(int[]) - Rotating Cover and moving wheel backwards", (bool)((ModSetting)Main.debugging).SavedValue);
				<i>5__4 = 0;
				goto IL_0195;
			case 1:
				<>1__state = -1;
				<i>5__4++;
				goto IL_0195;
			case 2:
				{
					<>1__state = -1;
					<i>5__8++;
					break;
				}
				IL_0195:
				if (<i>5__4 < 75)
				{
					<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, <>4__this.rotatingWheels.transform.localPosition.z - <movementPerTick>5__2);
					if (<i>5__4 >= 25)
					{
						<currentRotation>5__3 += 3.6f;
						((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, <currentRotation>5__3);
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, -0.023f);
				((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, 90f);
				Log("RandomizeSlots(int[]) - Setting Slots to Passed Data", (bool)((ModSetting)Main.debugging).SavedValue);
				<i>5__5 = 0;
				while (<i>5__5 < 3)
				{
					<>4__this.slotsOrder[<i>5__5] = new int[10];
					<j>5__6 = 0;
					while (<j>5__6 < 10)
					{
						<>4__this.slotsOrder[<i>5__5][<j>5__6] = newSlotsOrder[10 * <i>5__5 + <j>5__6];
						Log($"Slot {<i>5__5}: {<>4__this.slotsOrder[<i>5__5][<j>5__6]}", (bool)((ModSetting)Main.debugging).SavedValue);
						<j>5__6++;
					}
					<j>5__7 = 0;
					while (<j>5__7 < 10)
					{
						<>4__this.rotatingWheels.transform.GetChild(<i>5__5).GetChild(0).GetChild(<>4__this.slotsOrder[<i>5__5][<j>5__7])
							.localRotation = Quaternion.Euler(0f, 0f, 270f - (float)(<j>5__7 * 36));
						<j>5__7++;
					}
					Log($"Finished Slot {<i>5__5}: {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][0]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][1]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][2]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][3]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][4]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][5]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][6]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][7]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][8]]} {<>4__this.SlotsSpotTypesString[<>4__this.slotsOrder[<i>5__5][9]]}", (bool)((ModSetting)Main.debugging).SavedValue);
					<i>5__5++;
				}
				Log("RandomizeSlots(int[]) - Rotating Cover and moving wheel forwards", (bool)((ModSetting)Main.debugging).SavedValue);
				localRotation = <screen>5__1.localRotation;
				<currentRotation>5__3 = ((Quaternion)(ref localRotation)).eulerAngles.z;
				<i>5__8 = 0;
				break;
			}
			if (<i>5__8 < 75)
			{
				if (<i>5__8 < 50)
				{
					<currentRotation>5__3 += 3.6f;
					((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, <currentRotation>5__3);
				}
				<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, <>4__this.rotatingWheels.transform.localPosition.z + <movementPerTick>5__2);
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			<>4__this.rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, 0.017f);
			((Component)<screen>5__1).transform.localRotation = Quaternion.Euler(0f, 90f, 270f);
			<>4__this.SpinWheelsTillStopped();
			Log("RandomizeSlots Completed", (bool)((ModSetting)Main.debugging).SavedValue);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpinNumber>d__67 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public RevolvingNumber revolvingNumber;

		public int wheelSpot;

		public bool extraSpins;

		public SlotMachine <>4__this;

		private DateTime <minTime>5__1;

		private int <wheelNumber>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpinNumber>d__67(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<minTime>5__1 = DateTime.Now.AddSeconds(2f + (float)wheelSpot * ((wheelSpot == 1) ? 3f : 5f) + (extraSpins ? 5f : 0f));
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (DateTime.Now < <minTime>5__1)
			{
				<wheelNumber>5__2 = <>4__this.random.Next(0, 10);
				<>4__this.wheelsNumber[wheelSpot] = <wheelNumber>5__2;
				revolvingNumber.RotateToNumber(<>4__this.wheelsNumber[wheelSpot]);
				<>2__current = revolvingNumber.rotateCoroutine;
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpinWheelTillStoppedCoroutine>d__77 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int wheel;

		public SlotMachine <>4__this;

		private RevolvingNumber <revolvingNumber>5__1;

		private int <wheelNumber>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpinWheelTillStoppedCoroutine>d__77(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<revolvingNumber>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.clientSpinning[wheel] = true;
				<revolvingNumber>5__1 = ((Component)<>4__this.rotatingWheels.transform.GetChild(wheel)).GetComponent<RevolvingNumber>();
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)<revolvingNumber>5__1 != (Object)null && <>4__this.clientSpinning[wheel])
			{
				<wheelNumber>5__2 = <>4__this.random.Next(0, 10);
				<>4__this.wheelsNumber[wheel] = <wheelNumber>5__2;
				<revolvingNumber>5__1.RotateToNumber(<>4__this.wheelsNumber[wheel]);
				<>2__current = <revolvingNumber>5__1.rotateCoroutine;
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <StartWheelSpinSound>d__57 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotMachine <>4__this;

		private PooledAudioSource <pooledAudio>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <StartWheelSpinSound>d__57(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<pooledAudio>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.playingWheelSpinSound = true;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.playingWheelSpinSound)
			{
				<pooledAudio>5__1 = Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[2], <>4__this.soundsParent.transform.GetChild(2).position, false);
				<>2__current = (object)new WaitForSeconds(<pooledAudio>5__1.audioSource.clip.length * 2f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <WaitForWheelSpinsToFinishThenSetFinalSpot>d__69 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public int wheel;

		public int num;

		public SlotMachine <>4__this;

		private RevolvingNumber <revolvingNumber>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <WaitForWheelSpinsToFinishThenSetFinalSpot>d__69(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<revolvingNumber>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Log($"WaitForWheelSpinsToFinishThenSetFinalSpot({wheel} {num}) Started", (bool)((ModSetting)Main.debugging).SavedValue);
				if (<>4__this.clientSpinningCoroutines[wheel] != null)
				{
					<>4__this.clientSpinning[wheel] = false;
					<>2__current = <>4__this.clientSpinningCoroutines[wheel];
					<>1__state = 1;
					return true;
				}
				goto IL_00f9;
			case 1:
				<>1__state = -1;
				goto IL_00f9;
			case 2:
				<>1__state = -1;
				<revolvingNumber>5__1.RotateToNumber(num);
				<>4__this.wheelsNumber[wheel] = num;
				<>2__current = <revolvingNumber>5__1.rotateCoroutine;
				<>1__state = 3;
				return true;
			case 3:
				{
					<>1__state = -1;
					MelonCoroutines.Start(<>4__this.CheckWinPhase(isPlaying: false));
					Log($"WaitForWheelSpinsToFinishThenSetFinalSpot({wheel} {num}) Completed", (bool)((ModSetting)Main.debugging).SavedValue);
					return false;
				}
				IL_00f9:
				<revolvingNumber>5__1 = ((Component)<>4__this.rotatingWheels.transform.GetChild(wheel)).GetComponent<RevolvingNumber>();
				<>2__current = <revolvingNumber>5__1.rotateCoroutine;
				<>1__state = 2;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public Random random = null;

	private int seed = 0;

	public bool freePlay = false;

	public GameObject freePlayButton;

	public GameObject activeObjects;

	public GameObject rotatingWheels;

	public GameObject slotMachineTitleText;

	public GameObject coinsIn;

	public GameObject coinsOut;

	public GameObject topLight;

	public GameObject soundsParent;

	private InteractionLever lever;

	private GameObject[] betLines = (GameObject[])(object)new GameObject[5];

	private int[] wheelsNumber = new int[3];

	public int[][] slotsOrder = new int[3][];

	private SlotMachine instance = null;

	private List<SlotObjectAlternator> gemRotateActive = new List<SlotObjectAlternator>();

	private bool spinning = false;

	private object[] spinCoroutines = new object[3];

	private object spinBabySpin = null;

	private bool continueWheelSpinSound = false;

	private bool playingWheelSpinSound = false;

	private int amountPutIn = 0;

	private int amountGotOut = 0;

	public int betAmount = 1;

	private bool stopWinAnimation = false;

	public int[] setsPayouts = new int[10] { 1000, 70, 100, 200, 50, 90, 60, 80, 150, 45 };

	private string[] SlotsSpotTypesString = new string[10] { "Rumble", "AdamantStone", "ChargeStone", "FlowStone", "GuardStone", "StubbornStone", "SurgeStone", "VigorStone", "VolatileStone", "Howard" };

	private GameObject[] slotObjectOriginals;

	private PooledAudioSource playingAudio;

	private bool[] clientSpinning = new bool[3];

	private object[] clientSpinningCoroutines = new object[3];

	public static void Log(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Main.Log("SlotMachine - " + msg, sendMsg);
		}
	}

	public static void Warn(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Main.Warn("SlotMachine - " + msg, sendMsg);
		}
	}

	public static void Error(string msg)
	{
		Main.Error("SlotMachine - " + msg);
	}

	private void Start()
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		Log("Start Started", (bool)((ModSetting)Main.debugging).SavedValue);
		instance = this;
		activeObjects = ((Component)((Component)instance).transform.GetChild(1)).gameObject;
		rotatingWheels = ((Component)((Component)instance).transform.GetChild(2)).gameObject;
		rotatingWheels.transform.localPosition = new Vector3(-0.543f, 1.115f, 0.017f);
		betLines[0] = ((Component)((Component)instance).transform.GetChild(0).GetChild(4).GetChild(0)).gameObject;
		betLines[1] = ((Component)((Component)instance).transform.GetChild(0).GetChild(4).GetChild(1)).gameObject;
		betLines[2] = ((Component)((Component)instance).transform.GetChild(0).GetChild(4).GetChild(2)).gameObject;
		betLines[3] = ((Component)((Component)instance).transform.GetChild(0).GetChild(4).GetChild(3)).gameObject;
		betLines[4] = ((Component)((Component)instance).transform.GetChild(0).GetChild(4).GetChild(4)).gameObject;
		for (int i = 0; i < 3; i++)
		{
			((Component)rotatingWheels.transform.GetChild(i)).GetComponent<RevolvingNumber>().stepDuration = 0.3f;
		}
		slotObjectOriginals = (GameObject[])(object)new GameObject[10]
		{
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(0)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(1)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(2)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(3)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(4)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(5)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(6)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(7)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(8)).gameObject,
			((Component)rotatingWheels.transform.GetChild(0).GetChild(0).GetChild(9)).gameObject
		};
		topLight = ((Component)((Component)instance).transform.GetChild(0).GetChild(5)).gameObject;
		soundsParent = ((Component)((Component)instance).transform.GetChild(0).GetChild(6)).gameObject;
		SetupRandom();
		SetupStart();
		Log("Start Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void OnDestroy()
	{
		Log("OnDestroy Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if (spinCoroutines[2] != null)
		{
			MelonCoroutines.Stop(spinCoroutines[2]);
		}
		if (spinCoroutines[1] != null)
		{
			MelonCoroutines.Stop(spinCoroutines[1]);
		}
		if (spinCoroutines[0] != null)
		{
			MelonCoroutines.Stop(spinCoroutines[0]);
		}
		if (spinBabySpin != null)
		{
			MelonCoroutines.Stop(spinBabySpin);
		}
		while (gemRotateActive.Count > 0)
		{
			Object.Destroy((Object)(object)gemRotateActive[0]);
			gemRotateActive.RemoveAt(0);
		}
		Log("OnDestroy Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void FixWheels()
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		Log("FixWheels Called", (bool)((ModSetting)Main.debugging).SavedValue);
		for (int i = 0; i < 3; i++)
		{
			for (int j = 0; j < 10; j++)
			{
				rotatingWheels.transform.GetChild(i).GetChild(0).GetChild(slotsOrder[i][j])
					.localRotation = Quaternion.Euler(0f, 0f, 270f - (float)(j * 36));
			}
		}
	}

	public void SetupRandom()
	{
		Log("SetupRandom Started", (bool)((ModSetting)Main.debugging).SavedValue);
		string text = "0123456789";
		if (!(bool)((ModSetting)Main.useSeed).SavedValue)
		{
			Random random = new Random();
			int index = random.Next(1, 10);
			string text2 = text[index].ToString();
			for (int i = 1; i <= 8; i++)
			{
				text2 += text[random.Next(0, 10)];
			}
			seed = int.Parse(text2);
		}
		else
		{
			seed = Math.Min((int)((ModSetting)Main.tableSeed).SavedValue, 0);
		}
		((ModSetting)Main.slotsSeed).Value = seed;
		((ModSetting)Main.slotsSeed).SavedValue = seed;
		this.random = new Random(seed);
		Log("SetupRandom Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	public void SetupStart()
	{
		Log("SetupStart Started", (bool)((ModSetting)Main.debugging).SavedValue);
		SetupLever();
		SetupButtons();
		SetupSlotMachineSideWall();
		Log("SetupStart Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void SetupSlotMachineSideWall()
	{
		//IL_0041: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_020f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0223: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0305: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_036a: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0404: Unknown result type (might be due to invalid IL or missing references)
		//IL_0418: Unknown result type (might be due to invalid IL or missing references)
		//IL_042c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0465: Unknown result type (might be due to invalid IL or missing references)
		//IL_0479: Unknown result type (might be due to invalid IL or missing references)
		//IL_048d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0504: Unknown result type (might be due to invalid IL or missing references)
		//IL_0518: Unknown result type (might be due to invalid IL or missing references)
		//IL_052c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0552: Unknown result type (might be due to invalid IL or missing references)
		//IL_0566: Unknown result type (might be due to invalid IL or missing references)
		//IL_057a: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0604: Unknown result type (might be due to invalid IL or missing references)
		//IL_0618: Unknown result type (might be due to invalid IL or missing references)
		//IL_062c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0665: Unknown result type (might be due to invalid IL or missing references)
		//IL_0679: Unknown result type (might be due to invalid IL or missing references)
		//IL_068d: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_06da: Unknown result type (might be due to invalid IL or missing references)
		//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0717: Unknown result type (might be due to invalid IL or missing references)
		//IL_072b: Unknown result type (might be due to invalid IL or missing references)
		//IL_073f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0765: Unknown result type (might be due to invalid IL or missing references)
		//IL_0779: Unknown result type (might be due to invalid IL or missing references)
		//IL_078d: Unknown result type (might be due to invalid IL or missing references)
		//IL_07b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_07de: Unknown result type (might be due to invalid IL or missing references)
		//IL_0817: Unknown result type (might be due to invalid IL or missing references)
		//IL_082b: Unknown result type (might be due to invalid IL or missing references)
		//IL_083f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0878: Unknown result type (might be due to invalid IL or missing references)
		//IL_088c: Unknown result type (might be due to invalid IL or missing references)
		//IL_08a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_08d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_08ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0901: Unknown result type (might be due to invalid IL or missing references)
		//IL_092a: Unknown result type (might be due to invalid IL or missing references)
		//IL_093e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0952: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupSlotMachineSideWall Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = NewGameObject("SideMenu", ((Component)instance).transform.GetChild(0), new Vector3(18.5282f, 56.9347f, -17.3875f), Quaternion.Euler(0f, 180f, 0f), new Vector3(500f, 500f, 500f));
		GameObject val2 = NewGameObject("Line1", val.transform, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		GameObject val3 = NewGameObject("Gems1", val2.transform, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val3.transform, 0, includeHoward: true);
		GameObject val4 = NewGameObject("Gems2", val2.transform, new Vector3(0f, 0f, -0.015f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val4.transform, 0, includeHoward: true);
		GameObject val5 = NewGameObject("Gems3", val2.transform, new Vector3(0f, 0f, -0.03f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val5.transform, 0, includeHoward: true);
		GameObject val6 = NewGameObject("Texts", val2.transform, new Vector3(-0.021f, 0f, -0.047f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.2f, 0.2f, 0.2f));
		string[] title = new string[10] { "1000", "70", "100", "200", "50", "90", "60", "80", "150", "45" };
		SpawnAllTexts(val6.transform, title, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 90f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val7 = NewGameObject("Line2", val.transform, new Vector3(0f, -0.016f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		GameObject val8 = NewGameObject("Gems1", val7.transform, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val8.transform, 0);
		GameObject val9 = NewGameObject("Gems2", val7.transform, new Vector3(0f, 0f, -0.015f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val9.transform, 0);
		GameObject val10 = NewGameObject("Howard", val7.transform, new Vector3(0f, 0f, -0.03f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnSlotAsChild(val10.transform, 9);
		GameObject val11 = NewGameObject("Texts", val7.transform, new Vector3(-0.021f, 0f, -0.047f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.2f, 0.2f, 0.2f));
		string[] title2 = new string[9] { "100", "7", "10", "20", "5", "9", "6", "8", "15" };
		SpawnAllTexts(val11.transform, title2, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 90f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val12 = NewGameObject("Line3", val.transform, new Vector3(0f, -0.032f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		GameObject val13 = NewGameObject("Gems1", val12.transform, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val13.transform, 1);
		GameObject val14 = NewGameObject("Howard", val12.transform, new Vector3(0f, 0f, -0.015f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnSlotAsChild(val14.transform, 9);
		GameObject val15 = NewGameObject("Howard", val12.transform, new Vector3(0f, 0f, -0.03f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnSlotAsChild(val15.transform, 9);
		GameObject val16 = NewGameObject("Texts", val12.transform, new Vector3(-0.021f, 0f, -0.047f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.2f, 0.2f, 0.2f));
		SpawnText(val16.transform, "5", new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 90f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		GameObject val17 = NewGameObject("Line4", val.transform, new Vector3(0f, -0.048f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		GameObject val18 = NewGameObject("Gems1", val17.transform, new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val18.transform, 2);
		GameObject val19 = NewGameObject("Gems2", val17.transform, new Vector3(0f, 0f, -0.015f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnAllSlotsAsChildren(val19.transform, 3);
		GameObject val20 = NewGameObject("Howard", val17.transform, new Vector3(0f, 0f, -0.03f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
		SpawnSlotAsChild(val20.transform, 9);
		GameObject val21 = NewGameObject("Texts", val17.transform, new Vector3(-0.021f, 0f, -0.047f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.2f, 0.2f, 0.2f));
		SpawnText(val21.transform, "1", new Vector3(0f, 0f, 0f), Quaternion.Euler(0f, 90f, 0f), new Vector3(0.5f, 0.5f, 0.5f));
		Log("SetupSlotMachineSideWall - Starting Rotating Gems", (bool)((ModSetting)Main.debugging).SavedValue);
		SlotObjectAlternator item = new SlotObjectAlternator(val3);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val4);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val5);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val6);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val8);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val9);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val11);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val13);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val18);
		gemRotateActive.Add(item);
		item = new SlotObjectAlternator(val19);
		gemRotateActive.Add(item);
		Log("SetupSlotMachineSideWall Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private GameObject NewGameObject(string name, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale, GameObject objectToInstatiate = null)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Expected O, but got Unknown
		//IL_003d: 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_0058: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = (GameObject)((!((Object)(object)objectToInstatiate == (Object)null)) ? ((object)Object.Instantiate<GameObject>(objectToInstatiate)) : ((object)new GameObject(name)));
		((Object)val).name = name;
		val.transform.SetParent(parent);
		val.transform.localPosition = localPosition;
		val.transform.localRotation = localRotation;
		val.transform.localScale = localScale;
		return val;
	}

	private void SpawnAllSlotsAsChildren(Transform parent, int startingSpot, bool includeHoward = false)
	{
		for (int i = 0; i < 9 + (includeHoward ? 1 : 0); i++)
		{
			SpawnSlotAsChild(parent, startingSpot);
			startingSpot++;
			if (startingSpot == 9 + (includeHoward ? 1 : 0))
			{
				startingSpot = 0;
			}
		}
	}

	private void SpawnSlotAsChild(Transform parent, int spot)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: 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)
		GameObject val = Object.Instantiate<GameObject>(slotObjectOriginals[spot]);
		((Object)val).name = SlotsSpotTypesString[spot];
		val.transform.SetParent(parent);
		val.transform.localPosition = Vector3.zero;
		val.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
		val.transform.localScale = Vector3.one;
	}

	public void SpawnAllTexts(Transform parent, string[] title, Vector3 position, Quaternion rotation, Vector3 localScale)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < title.Length; i++)
		{
			SpawnText(parent, title[i], position, rotation, localScale);
		}
	}

	private void SetupButtons()
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		//IL_0215: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Unknown result type (might be due to invalid IL or missing references)
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_026d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupButtons Started", (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = LoadMenuButton("1 Row", new Vector3(0.31f, 0.87f, 0.3f), Quaternion.Euler(15f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), onButtonTop: true, delegate
		{
			((MonoBehaviourPun)this).photonView.RPC("RPC_BetButtonPressed", (RpcTarget)1, (Object[])(object)new Object[1] { Object.op_Implicit(0) });
			BetButtonPressed(0);
		});
		GameObject val2 = LoadMenuButton("3 Row", new Vector3(0.09f, 0.87f, 0.3f), Quaternion.Euler(15f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), onButtonTop: true, delegate
		{
			((MonoBehaviourPun)this).photonView.RPC("RPC_BetButtonPressed", (RpcTarget)1, (Object[])(object)new Object[1] { Object.op_Implicit(1) });
			BetButtonPressed(1);
		});
		GameObject val3 = LoadMenuButton("5 Row", new Vector3(-0.14f, 0.87f, 0.3f), Quaternion.Euler(15f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), onButtonTop: true, delegate
		{
			((MonoBehaviourPun)this).photonView.RPC("RPC_BetButtonPressed", (RpcTarget)1, (Object[])(object)new Object[1] { Object.op_Implicit(2) });
			BetButtonPressed(2);
		});
		freePlayButton = LoadMenuButton("FreePlay", new Vector3(0.4f, 0.7f, 0.4f), Quaternion.Euler(90f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), onButtonTop: false, delegate
		{
			if (!spinning && !(bool)((ModSetting)Main.useSeed).SavedValue)
			{
				SetFreePlay(!freePlay);
				((MonoBehaviourPun)this).photonView.RPC("RPC_FreePlayPressed", (RpcTarget)1, (Object[])(object)new Object[1] { Object.op_Implicit(freePlay) });
			}
		});
		slotMachineTitleText = SpawnText(activeObjects.transform, "Title", new Vector3(0.19f, 1.47f, 0.21f), Quaternion.Euler(13f, 180f, 0f), new Vector3(1f, 1f, 1f));
		coinsIn = SpawnText(activeObjects.transform, "Coins In", new Vector3(0.38f, 0.57f, 0.41f), Quaternion.Euler(0f, 180f, 0f), new Vector3(1f, 1f, 1f));
		coinsOut = SpawnText(activeObjects.transform, "Coins Out", new Vector3(0.34f, 0.47f, 0.41f), Quaternion.Euler(0f, 180f, 0f), new Vector3(1f, 1f, 1f));
		SetFreePlay(freePlay);
		betAmount = 1;
		UpdateBetLines();
		((TMP_Text)((Component)activeObjects.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.green;
		((TMP_Text)((Component)activeObjects.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
		((TMP_Text)((Component)activeObjects.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
		TextMeshPro component = slotMachineTitleText.GetComponent<TextMeshPro>();
		TextMeshPro component2 = coinsIn.GetComponent<TextMeshPro>();
		TextMeshPro component3 = coinsOut.GetComponent<TextMeshPro>();
		((TMP_Text)component).text = "Ready To Play!";
		((TMP_Text)component2).text = "In: 0";
		((TMP_Text)component3).text = "Out: 0";
		((TMP_Text)component).alignment = (TextAlignmentOptions)513;
		((TMP_Text)component2).alignment = (TextAlignmentOptions)513;
		((TMP_Text)component3).alignment = (TextAlignmentOptions)513;
		((TMP_Text)component).enableWordWrapping = false;
		((TMP_Text)component2).enableWordWrapping = false;
		((TMP_Text)component3).enableWordWrapping = false;
		Log("SetupButtons Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	[PunRPC]
	public void RPC_FreePlayPressed(bool isFreePlay)
	{
		SetFreePlay(isFreePlay);
	}

	private void BetButtonPressed(int button)
	{
		//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)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		if (!spinning)
		{
			switch (button)
			{
			case 0:
				((TMP_Text)((Component)activeObjects.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.green;
				((TMP_Text)((Component)activeObjects.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				((TMP_Text)((Component)activeObjects.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				betAmount = 1;
				break;
			case 1:
				((TMP_Text)((Component)activeObjects.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				((TMP_Text)((Component)activeObjects.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.green;
				((TMP_Text)((Component)activeObjects.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				betAmount = 3;
				break;
			case 2:
				((TMP_Text)((Component)activeObjects.transform.GetChild(0).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				((TMP_Text)((Component)activeObjects.transform.GetChild(1).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.black;
				((TMP_Text)((Component)activeObjects.transform.GetChild(2).GetChild(2)).GetComponent<TextMeshPro>()).color = Color.green;
				betAmount = 5;
				break;
			case 3:
				SetFreePlay(!freePlay);
				break;
			}
			UpdateBetLines();
		}
	}

	private void UpdateBetLines()
	{
		Log("UpdateBetLines Called", (bool)((ModSetting)Main.debugging).SavedValue);
		betLines[1].SetActive(betAmount >= 3);
		betLines[2].SetActive(betAmount >= 3);
		betLines[3].SetActive(betAmount == 5);
		betLines[4].SetActive(betAmount == 5);
	}

	private void SetupLever()
	{
		Log("SetupLever Started", (bool)((ModSetting)Main.debugging).SavedValue);
		lever = ((Component)((Component)instance).transform.GetChild(0).GetChild(0).GetChild(2)).gameObject.AddComponent<InteractionLever>();
		InteractionLever interactionLever = lever;
		interactionLever.LeverPulled = (Action)Delegate.Combine(interactionLever.LeverPulled, new Action(PulledLever));
		InteractionLever interactionLever2 = lever;
		interactionLever2.OnLeverReleased = (Action)Delegate.Combine(interactionLever2.OnLeverReleased, new Action(ToggleLeverRelease));
		InteractionLever interactionLever3 = lever;
		interactionLever3.OnLeverReleasedComplete = (Action)Delegate.Combine(interactionLever3.OnLeverReleasedComplete, new Action(ToggleLeverReleaseComplete));
		Log("SetupLever Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void ToggleLeverRelease()
	{
		Log("ToggleLeverRelease Called", (bool)((ModSetting)Main.debugging).SavedValue);
		MelonCoroutines.Start(PlayWheelSpinSoundTillStopped());
	}

	private void ToggleLeverReleaseComplete()
	{
		Log("ToggleLeverReleaseComplete Called", (bool)((ModSetting)Main.debugging).SavedValue);
		continueWheelSpinSound = false;
		if (!((PooledMonoBehaviour)playingAudio).IsInPool)
		{
			((PooledMonoBehaviour)playingAudio).ReturnToPool();
		}
	}

	[IteratorStateMachine(typeof(<PlayWheelSpinSoundTillStopped>d__50))]
	private IEnumerator PlayWheelSpinSoundTillStopped()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayWheelSpinSoundTillStopped>d__50(0)
		{
			<>4__this = this
		};
	}

	public void SetFreePlay(bool isFreePlay)
	{
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		Log($"SetFreePlay({isFreePlay}) Called", (bool)((ModSetting)Main.debugging).SavedValue);
		freePlay = isFreePlay;
		((TMP_Text)((Component)freePlayButton.transform.GetChild(2)).GetComponent<TextMeshPro>()).color = (freePlay ? Color.green : Color.red);
	}

	public void PulledLever()
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Invalid comparison between Unknown and I4
		Log("Pulled Lever Called", (bool)((ModSetting)Main.debugging).SavedValue);
		if (IsSpinning() || (!freePlay && !PlayerHasEnoughCoins()))
		{
			return;
		}
		try
		{
			if ((int)lever.lastInteractedPlayer.Controller.controllerType != 1)
			{
				return;
			}
		}
		catch
		{
			return;
		}
		if (!freePlay)
		{
			Main.Payout(-betAmount, 1f, this);
			amountPutIn += betAmount;
			((TMP_Text)coinsIn.GetComponent<TextMeshPro>()).text = "In: " + amountPutIn;
			PlayCoinInsertSound();
		}
		stopWinAnimation = true;
		object obj2 = MelonCoroutines.Start(PlaySpin());
	}

	private void PlayCoinInsertSound()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		Log("PlayCoinInsertSound Started", (bool)((ModSetting)Main.debugging).SavedValue);
		Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[1], soundsParent.transform.GetChild(1).position, false);
	}

	private bool PlayerHasEnoughCoins()
	{
		return Main.GetPlayerCoinCount() >= betAmount;
	}

	[PunRPC]
	public void RPC_BetButtonPressed(short button)
	{
		Log($"RPC_BetButtonPressed({button}) Called", (bool)((ModSetting)Main.debugging).SavedValue);
		BetButtonPressed(button);
	}

	[IteratorStateMachine(typeof(<PlaySpin>d__56))]
	private IEnumerator PlaySpin()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlaySpin>d__56(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<StartWheelSpinSound>d__57))]
	private IEnumerator StartWheelSpinSound()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <StartWheelSpinSound>d__57(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<CheckWinPhase>d__58))]
	private IEnumerator CheckWinPhase(bool isPlaying = true)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <CheckWinPhase>d__58(0)
		{
			<>4__this = this,
			isPlaying = isPlaying
		};
	}

	private void PlayNoPayoutSound()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		Log("PlayNoPayoutSound Called", (bool)((ModSetting)Main.debugging).SavedValue);
		Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[5], soundsParent.transform.GetChild(3).position, false);
	}

	[IteratorStateMachine(typeof(<AnimateTopLight>d__60))]
	private IEnumerator AnimateTopLight(int payout)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AnimateTopLight>d__60(0)
		{
			<>4__this = this,
			payout = payout
		};
	}

	private void PlayPayoutSound()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		Log("PlayPayoutSound Called", (bool)((ModSetting)Main.debugging).SavedValue);
		Singleton<AudioManager>.instance.Play(Main.storedAudioCalls[3], soundsParent.transform.GetChild(3).position, false);
	}

	[IteratorStateMachine(typeof(<PlayBigPayoutSound>d__62))]
	private IEnumerator PlayBigPayoutSound(int payout)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayBigPayoutSound>d__62(0)
		{
			<>4__this = this,
			payout = payout
		};
	}

	[IteratorStateMachine(typeof(<DisplayWinOnTop>d__63))]
	private IEnumerator DisplayWinOnTop(int[] line)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DisplayWinOnTop>d__63(0)
		{
			<>4__this = this,
			line = line
		};
	}

	[IteratorStateMachine(typeof(<FlashColors>d__64))]
	private IEnumerator FlashColors(GameObject betLine)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <FlashColors>d__64(0)
		{
			<>4__this = this,
			betLine = betLine
		};
	}

	private int CheckWinLine(int[] line)
	{
		Log($"CheckWinLine: {line[0]} {line[1]} {line[2]}", (bool)((ModSetting)Main.debugging).SavedValue);
		int num = 0;
		int num2 = 0;
		for (int i = 0; i < 3; i++)
		{
			if (line[i] == 9)
			{
				num2++;
			}
		}
		switch (num2)
		{
		case 1:
			if ((line[0] == line[1] && line[2] == 9) || (line[0] == line[2] && line[1] == 9) || (line[1] == line[2] && line[0] == 9))
			{
				int num4 = setsPayouts[(line[0] == 9) ? line[1] : line[0]] / 10;
				Log($"Line: {SlotsSpotTypesString[line[0]]} {SlotsSpotTypesString[line[1]]} {SlotsSpotTypesString[line[2]]} is a Winner, Paying {num4} Coins (1 Howard + 2 Matching)");
				num += num4;
			}
			else
			{
				Log($"Line: {SlotsSpotTypesString[line[0]]} {SlotsSpotTypesString[line[1]]} {SlotsSpotTypesString[line[2]]} is a Winner, Paying 1 Coin (1 Howard in a Row)");
				num++;
			}
			break;
		case 2:
			Log($"Line: {SlotsSpotTypesString[line[0]]} {SlotsSpotTypesString[line[1]]} {SlotsSpotTypesString[line[2]]} is a Winner, Paying 5 Coins (2 Howards in a Row)");
			num += 5;
			break;
		default:
			if (line[0] == line[1] && line[1] == line[2])
			{
				if (1 < line[0] && line[0] < 9)
				{
					MelonCoroutines.Start(PlayShiftStoneSound());
				}
				int num3 = setsPayouts[line[0]];
				Log($"Line: {SlotsSpotTypesString[line[0]]} {SlotsSpotTypesString[line[1]]} {SlotsSpotTypesString[line[2]]} is a Winner, Paying {num3} Coins (All 3 Match)");
				num += num3;
			}
			break;
		}
		return num;
	}

	[IteratorStateMachine(typeof(<PlayShiftStoneSound>d__66))]
	private IEnumerator PlayShiftStoneSound()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PlayShiftStoneSound>d__66(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<SpinNumber>d__67))]
	private IEnumerator SpinNumber(RevolvingNumber revolvingNumber, int wheelSpot, bool extraSpins)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpinNumber>d__67(0)
		{
			<>4__this = this,
			revolvingNumber = revolvingNumber,
			wheelSpot = wheelSpot,
			extraSpins = extraSpins
		};
	}

	[PunRPC]
	public void RPC_RotateToNumber(short wheel, short num)
	{
		Log("RPC_RotateToNumber Called", (bool)((ModSetting)Main.debugging).SavedValue);
		MelonCoroutines.Start(WaitForWheelSpinsToFinishThenSetFinalSpot(wheel, num));
	}

	[IteratorStateMachine(typeof(<WaitForWheelSpinsToFinishThenSetFinalSpot>d__69))]
	private IEnumerator WaitForWheelSpinsToFinishThenSetFinalSpot(int wheel, int num)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <WaitForWheelSpinsToFinishThenSetFinalSpot>d__69(0)
		{
			<>4__this = this,
			wheel = wheel,
			num = num
		};
	}

	public bool IsSpinning()
	{
		return spinning;
	}

	[IteratorStateMachine(typeof(<RandomizeSlots>d__71))]
	private IEnumerator RandomizeSlots()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RandomizeSlots>d__71(0)
		{
			<>4__this = this
		};
	}

	[PunRPC]
	public void RPC_RandomizeSlots(bool isFreePlay, short thisBetAmount, short num0, short num1, short num2, short num3, short num4, short num5, short num6, short num7, short num8, short num9, short num10, short num11, short num12, short num13, short num14, short num15, short num16, short num17, short num18, short num19, short num20, short num21, short num22, short num23, short num24, short num25, short num26, short num27, short num28, short num29)
	{
		Log("RPC_RandomizeSlots Called", (bool)((ModSetting)Main.debugging).SavedValue);
		SetFreePlay(isFreePlay);
		betAmount = thisBetAmount;
		UpdateBetLines();
		stopWinAnimation = true;
		spinning = true;
		int[] newSlotsOrder = new int[30]
		{
			num0, num1, num2, num3, num4, num5, num6, num7, num8, num9,
			num10, num11, num12, num13, num14, num15, num16, num17, num18, num19,
			num20, num21, num22, num23, num24, num25, num26, num27, num28, num29
		};
		MelonCoroutines.Start(RandomizeSlots(newSlotsOrder));
	}

	[IteratorStateMachine(typeof(<RandomizeSlots>d__73))]
	private IEnumerator RandomizeSlots(int[] newSlotsOrder)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RandomizeSlots>d__73(0)
		{
			<>4__this = this,
			newSlotsOrder = newSlotsOrder
		};
	}

	private void SpinWheelsTillStopped()
	{
		Log("SpinWheelsTillStopped Called", (bool)((ModSetting)Main.debugging).SavedValue);
		MelonCoroutines.Start(StartWheelSpinSound());
		((TMP_Text)slotMachineTitleText.GetComponent<TextMeshPro>()).text = "Spinning Wheels";
		clientSpinningCoroutines[0] = MelonCoroutines.Start(SpinWheelTillStoppedCoroutine(0));
		clientSpinningCoroutines[1] = MelonCoroutines.Start(SpinWheelTillStoppedCoroutine(1));
		clientSpinningCoroutines[2] = MelonCoroutines.Start(SpinWheelTillStoppedCoroutine(2));
	}

	[IteratorStateMachine(typeof(<SpinWheelTillStoppedCoroutine>d__77))]
	private IEnumerator SpinWheelTillStoppedCoroutine(int wheel)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpinWheelTillStoppedCoroutine>d__77(0)
		{
			<>4__this = this,
			wheel = wheel
		};
	}

	public GameObject LoadMenuButton(string title, Vector3 position, Quaternion rotation, Vector3 localScale, bool onButtonTop, Action listener = null)
	{
		//IL_0063: 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)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: 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)
		Log("Loading Menu Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = ((listener != null) ? Create.NewButton(listener) : Create.NewButton());
		((Object)val).name = title + " Button";
		val.transform.SetParent(activeObjects.transform);
		val.transform.localPosition = new Vector3(position.x, position.y, position.z);
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		LoadText(val, title, onButtonTop);
		Log("Done Loading Menu Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	public GameObject SpawnText(Transform parent, string title, Vector3 position, Quaternion rotation, Vector3 localScale)
	{
		//IL_004c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
		Log("Loading Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Create.NewText();
		((Object)val).name = title + " Text";
		val.transform.SetParent(parent);
		val.transform.localPosition = position;
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
		((TMP_Text)component).text = title;
		Log("Done Loading Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	public void LoadText(GameObject button, string title, bool onButtonTop)
	{
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		Log("Loading Menu Button Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Create.NewText();
		((Object)val).name = title + "Text";
		val.transform.SetParent(button.transform);
		val.transform.localPosition = (onButtonTop ? new Vector3(0f, 0.01f, -0.22f) : new Vector3(-0.3f, 0f, 0f));
		val.transform.localRotation = Quaternion.Euler(90f, 180f, 0f);
		val.transform.localScale = Vector3.one;
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
		((TMP_Text)component).text = title;
		Log("Done Loading Menu Button Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
	}
}
public class SlotObjectAlternator : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <Run>d__4 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public SlotObjectAlternator <>4__this;

		private int <spot>5__1;

		private int <childCount>5__2;

		private int <i>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <Run>d__4(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<spot>5__1 = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)<>4__this.gemsParent != (Object)null)
			{
				<spot>5__1++;
				<childCount>5__2 = <>4__this.gemsParent.transform.childCount;
				if (<spot>5__1 == <childCount>5__2)
				{
					<spot>5__1 = 0;
				}
				<i>5__3 = 0;
				while (<i>5__3 < <childCount>5__2)
				{
					((Component)<>4__this.gemsParent.transform.GetChild(<i>5__3)).gameObject.SetActive(<i>5__3 == <spot>5__1);
					<i>5__3++;
				}
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private GameObject gemsParent;

	private object gemsRotateCoroutine;

	public SlotObjectAlternator(GameObject gemsParent)
	{
		this.gemsParent = gemsParent;
		gemsRotateCoroutine = MelonCoroutines.Start(Run());
	}

	private void OnDestroy()
	{
		MelonCoroutines.Stop(gemsRotateCoroutine);
	}

	[IteratorStateMachine(typeof(<Run>d__4))]
	private IEnumerator Run()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <Run>d__4(0)
		{
			<>4__this = this
		};
	}
}
public enum Games
{
	BlackJack,
	JacksOrBetter
}
[RegisterTypeInIl2Cpp]
public class Table : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <LoadGameCoroutine>d__19 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public Games game;

		public Table <>4__this;

		private object <gameRunningCoroutine>5__1;

		private Games <>s__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <LoadGameCoroutine>d__19(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<gameRunningCoroutine>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<gameRunningCoroutine>5__1 = null;
				Games games = game;
				<>s__2 = games;
				switch (<>s__2)
				{
				case Games.BlackJack:
					Log("Game BlackJack Started!", (bool)((ModSetting)Main.debugging).SavedValue);
					<>4__this.blackJackInstance = new BlackJack(<>4__this.instance);
					<>4__this.blackJackInstance.ShowSplash();
					<gameRunningCoroutine>5__1 = MelonCoroutines.Start(<>4__this.blackJackInstance.Run());
					break;
				case Games.JacksOrBetter:
					Log("Game JacksOrBetter Started!", (bool)((ModSetting)Main.debugging).SavedValue);
					<>4__this.jacksOrBetterInstance = new JacksOrBetter(<>4__this.instance);
					<>4__this.jacksOrBetterInstance.ShowSplash();
					<gameRunningCoroutine>5__1 = MelonCoroutines.Start(<>4__this.jacksOrBetterInstance.Run());
					break;
				default:
					return false;
				}
				<>2__current = <gameRunningCoroutine>5__1;
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				<>4__this.ClearActiveObjects();
				Log("Game Completed!", (bool)((ModSetting)Main.debugging).SavedValue);
				<>4__this.SetupStart();
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpinCard>d__23 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject card;

		public Table <>4__this;

		private int <fixedUpdatesToCompleteSpin>5__1;

		private int <updatesLeft>5__2;

		private float <amountToSpin>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpinCard>d__23(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds((float)<>4__this.random.Next(10, 50) / 100f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<fixedUpdatesToCompleteSpin>5__1 = <>4__this.random.Next(25, 50);
				<updatesLeft>5__2 = <fixedUpdatesToCompleteSpin>5__1;
				<amountToSpin>5__3 = 360f / (float)<fixedUpdatesToCompleteSpin>5__1;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<updatesLeft>5__2 >= 0)
			{
				try
				{
					card.transform.localRotation = Quaternion.Euler(card.transform.localRotation.x, card.transform.localRotation.y, <amountToSpin>5__3 * (float)(<fixedUpdatesToCompleteSpin>5__1 - <updatesLeft>5__2));
				}
				catch
				{
					return false;
				}
				<updatesLeft>5__2--;
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public string[] CardString = new string[52]
	{
		"AS", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", "10S",
		"JS", "QS", "KS", "AH", "2H", "3H", "4H", "5H", "6H", "7H",
		"8H", "9H", "10H", "JH", "QH", "KH", "AD", "2D", "3D", "4D",
		"5D", "6D", "7D", "8D", "9D", "10D", "JD", "QD", "KD", "AC",
		"2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "10C", "JC",
		"QC", "KC"
	};

	public float TABLEHEIGHT;

	public Random random = null;

	private int seed = 0;

	public bool freePlay = false;

	public GameObject dealerDeck;

	public GameObject storedDeckOfCards;

	public GameObject freePlayButton;

	private Table instance = null;

	public BlackJack blackJackInstance = null;

	public JacksOrBetter jacksOrBetterInstance = null;

	public static void Log(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Main.Log("Table - " + msg, sendMsg);
		}
	}

	public static void Warn(string msg, bool sendMsg = true)
	{
		if (sendMsg)
		{
			Main.Warn("Table - " + msg, sendMsg);
		}
	}

	public static void Error(string msg)
	{
		Main.Error("Table - " + msg);
	}

	private void Start()
	{
		Log("Start Started", (bool)((ModSetting)Main.debugging).SavedValue);
		instance = this;
		TABLEHEIGHT = 0.9974f;
		dealerDeck = ((Component)((Component)this).transform.GetChild(0).GetChild(16)).gameObject;
		storedDeckOfCards = ((Component)((Component)this).transform.GetChild(1).GetChild(0)).gameObject;
		SetupRandom();
		SetupStart();
		Log("Start Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void OnDestroy()
	{
		Log("OnDestroy Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if ((Object)(object)blackJackInstance != (Object)null)
		{
			MelonCoroutines.Stop((object)blackJackInstance);
		}
		if ((Object)(object)jacksOrBetterInstance != (Object)null)
		{
			MelonCoroutines.Stop((object)jacksOrBetterInstance);
		}
		Log("OnDestroy Completed", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	public void SetupRandom()
	{
		Log("SetupRandom Started", (bool)((ModSetting)Main.debugging).SavedValue);
		string text = "0123456789";
		if (!(bool)((ModSetting)Main.useSeed).SavedValue)
		{
			Random random = new Random();
			int index = random.Next(1, 10);
			string text2 = text[index].ToString();
			for (int i = 1; i <= 8; i++)
			{
				text2 += text[random.Next(0, 10)];
			}
			seed = int.Parse(text2);
		}
		else
		{
			seed = Math.Min((int)((ModSetting)Main.tableSeed).SavedValue, 0);
		}
		((ModSetting)Main.tableSeed).Value = seed;
		((ModSetting)Main.tableSeed).SavedValue = seed;
		this.random = new Random(seed);
		Log("SetupRandom Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	public void SetupStart()
	{
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: 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_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		Log("SetupStart Started", (bool)((ModSetting)Main.debugging).SavedValue);
		if (!(bool)((ModSetting)Main.useSeed).SavedValue)
		{
			freePlayButton = LoadMenuButton("FreePlay", new Vector3(0f, TABLEHEIGHT - 0.05f, 0.6f), Quaternion.Euler(0f, 0f, 0f), new Vector3(0.5f, 0.5f, 0.5f), delegate
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				freePlay = !freePlay;
				((TMP_Text)((Component)((Component)this).gameObject.transform.GetChild(2).FindChild("FreePlay Button/FreePlayText")).GetComponent<TextMeshPro>()).color = (freePlay ? Color.green : Color.red);
			});
			if ((Object)(object)freePlayButton != (Object)null)
			{
				((TMP_Text)((Component)freePlayButton.transform.GetChild(2)).GetComponent<TextMeshPro>()).color = (freePlay ? Color.green : Color.red);
			}
		}
		LoadMenuButton("BlackJack", new Vector3(0.55f, TABLEHEIGHT - 0.05f, 0.6f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f), delegate
		{
			LoadGame(Games.BlackJack);
		});
		LoadMenuButton("Jacks Or Better", new Vector3(-0.55f, TABLEHEIGHT - 0.05f, 0.6f), Quaternion.Euler(0f, 0f, 0f), new Vector3(1f, 1f, 1f), delegate
		{
			LoadGame(Games.JacksOrBetter);
		});
		Log("SetupStart Complete", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	private void LoadGame(Games game)
	{
		Log("Loading Game: " + game, (bool)((ModSetting)Main.debugging).SavedValue);
		ClearActiveObjects();
		MelonCoroutines.Start(LoadGameCoroutine(game));
	}

	[IteratorStateMachine(typeof(<LoadGameCoroutine>d__19))]
	private IEnumerator LoadGameCoroutine(Games game)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <LoadGameCoroutine>d__19(0)
		{
			<>4__this = this,
			game = game
		};
	}

	public void ClearActiveObjects()
	{
		Log("Clearing Active Objects", (bool)((ModSetting)Main.debugging).SavedValue);
		Transform child = ((Component)instance).transform.GetChild(2);
		for (int num = child.GetChildCount() - 1; num >= 0; num--)
		{
			Log("Clearing Active Object: " + ((Object)((Component)child.GetChild(num)).gameObject).name, (bool)((ModSetting)Main.debugging).SavedValue);
			Object.Destroy((Object)(object)((Component)child.GetChild(num)).gameObject);
		}
		Log("Done Clearing Active Objects", (bool)((ModSetting)Main.debugging).SavedValue);
	}

	public GameObject LoadMenuButton(string title, Vector3 position, Quaternion rotation, Vector3 localScale, Action listener = null)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		Log("Loading Menu Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = ((listener != null) ? Create.NewButton(listener) : Create.NewButton());
		((Object)val).name = title + " Button";
		val.transform.SetParent(((Component)this).transform.GetChild(2));
		val.transform.localPosition = new Vector3(position.x, position.y, position.z);
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		LoadText(val, title);
		Log("Done Loading Menu Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	public object[] ShuffleDealerDeck()
	{
		Transform child = dealerDeck.transform.GetChild(0).GetChild(0).GetChild(0);
		object[] array = new object[child.GetChildCount()];
		for (int i = 0; i < child.GetChildCount(); i++)
		{
			array[i] = MelonCoroutines.Start(SpinCard(((Component)child.GetChild(i)).gameObject));
		}
		return array;
	}

	[IteratorStateMachine(typeof(<SpinCard>d__23))]
	public IEnumerator SpinCard(GameObject card)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpinCard>d__23(0)
		{
			<>4__this = this,
			card = card
		};
	}

	public GameObject SpawnButton(Transform parent, string title, Vector3 position, Quaternion rotation, Vector3 localScale, Action listener = null)
	{
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		Log("Loading Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = ((listener != null) ? Create.NewButton(listener) : Create.NewButton());
		((Object)val).name = title + " Button";
		val.transform.SetParent(parent);
		val.transform.localPosition = position;
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		LoadText(val, title);
		Log("Done Loading Button: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	public GameObject SpawnText(Transform parent, string title, Vector3 position, Quaternion rotation, Vector3 localScale)
	{
		//IL_004c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
		Log("Loading Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Create.NewText();
		((Object)val).name = title + " Text";
		val.transform.SetParent(parent);
		val.transform.localPosition = position;
		val.transform.localRotation = rotation;
		val.transform.localScale = localScale;
		((TMP_Text)val.GetComponent<TextMeshPro>()).text = title;
		Log("Done Loading Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		return val;
	}

	public void LoadText(GameObject button, string title)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: 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)
		Log("Loading Menu Button Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
		GameObject val = Create.NewText();
		((Object)val).name = title + "Text";
		val.transform.SetParent(button.transform);
		val.transform.localPosition = new Vector3(0f, 0f, -0.25f);
		val.transform.localRotation = Quaternion.Euler(90f, 180f, 0f);
		val.transform.localScale = Vector3.one;
		TextMeshPro component = val.GetComponent<TextMeshPro>();
		((TMP_Text)component).alignment = (TextAlignmentOptions)514;
		((TMP_Text)component).enableWordWrapping = false;
		((TMP_Text)component).text = title;
		Log("Done Loading Menu Button Text: " + title, (bool)((ModSetting)Main.debugging).SavedValue);
	}
}