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.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using ExitGames.Client.Photon;
using HarmonyLib;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.Rendering;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("peakmod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("peakmod")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("151563ae-3187-4437-8520-701a4dbc2edc")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PeakCloudArena;

[BepInPlugin("songt.peak.cloudarena", "PEAK Party Games", "5.21.6")]
public class Plugin : BaseUnityPlugin, IOnEventCallback
{
	public enum GameState
	{
		Idle,
		SpawningArena,
		RoundStarting,
		Running,
		RoundEnding,
		GameEnding
	}

	public enum RoundGameType
	{
		CloudDynamite,
		ShelfHook,
		BounceFrisbee,
		DoubleCloudCoconut,
		RhythmGame,
		ColorCloudSurvival,
		ButtonMashRace,
		StarGrid,
		MemoryMatch,
		HalliGalli,
		DinoRun
	}

	public enum DirectPrefabMode
	{
		AutoFromItem,
		ManualPath
	}

	private enum Round6CloudColor
	{
		Green,
		Yellow,
		Orange,
		Purple,
		Red
	}

	private class ArenaTile
	{
		public GameObject obj;

		public Vector3 position;

		public int layerIndex;

		public ArenaTile(GameObject obj, Vector3 position, int layerIndex)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			this.obj = obj;
			this.position = position;
			this.layerIndex = layerIndex;
		}
	}

	private sealed class FungusFrameLocker : MonoBehaviour
	{
		private Transform[] transforms;

		private Vector3[] localPositions;

		private Quaternion[] localRotations;

		private Vector3[] localScales;

		public void Capture(Transform root)
		{
			//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)
			//IL_008c: 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_009e: 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)
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			transforms = ((Component)root).GetComponentsInChildren<Transform>(true);
			localPositions = (Vector3[])(object)new Vector3[transforms.Length];
			localRotations = (Quaternion[])(object)new Quaternion[transforms.Length];
			localScales = (Vector3[])(object)new Vector3[transforms.Length];
			for (int i = 0; i < transforms.Length; i++)
			{
				Transform val = transforms[i];
				if (!((Object)(object)val == (Object)null))
				{
					localPositions[i] = val.localPosition;
					localRotations[i] = val.localRotation;
					localScales[i] = val.localScale;
				}
			}
		}

		private void LateUpdate()
		{
			//IL_0035: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			if (transforms == null)
			{
				return;
			}
			for (int i = 0; i < transforms.Length; i++)
			{
				Transform val = transforms[i];
				if (!((Object)(object)val == (Object)null))
				{
					try
					{
						val.localPosition = localPositions[i];
						val.localRotation = localRotations[i];
						val.localScale = localScales[i];
					}
					catch
					{
					}
				}
			}
		}
	}

	[CompilerGenerated]
	private sealed class <>c__DisplayClass881_0
	{
		public RoundGameType roundType;

		internal void <AutoGameRoutine>b__0(RoundGameType selected)
		{
			roundType = selected;
		}
	}

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

		private object <>2__current;

		public Plugin <>4__this;

		private int <roundsToPlay>5__1;

		private <>c__DisplayClass881_0 <>8__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Expected O, but got Unknown
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.finalEndingTriggered = false;
				<>4__this.finalScoreboardActive = false;
				<>4__this.roundBetweenMovementLockUntil = -1f;
				<>4__this.firstRoundStartedAfterMapLoad = true;
				<>4__this.BuildRoundOrder();
				<>4__this.currentRoundIndex = 0;
				<>4__this.mainRoundPlayedCount = 0;
				<>4__this.votedPlayedRounds.Clear();
				<>4__this.ClearRoundResultPodiums();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.SpawnRoundResultPodiumsForGameRoutine());
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<roundsToPlay>5__1 = Mathf.Clamp((<>4__this.totalMainRounds != null) ? <>4__this.totalMainRounds.Value : 7, 1, 7);
				<roundsToPlay>5__1 = 7;
				goto IL_0329;
			case 2:
				<>1__state = -1;
				if (!<>4__this.gameStart.Value)
				{
					goto IL_035a;
				}
				if (!<>4__this.votedPlayedRounds.Contains(<>8__2.roundType))
				{
					<>4__this.votedPlayedRounds.Add(<>8__2.roundType);
				}
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.RunRoundRoutine(<>8__2.roundType, testMode: false));
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.WaitForRoundEndPresentationCompleteRoutine("AfterRunRoundRoutine"));
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.mainRoundPlayedCount++;
				if (<>4__this.gameStart.Value && <>4__this.mainRoundPlayedCount < <roundsToPlay>5__1)
				{
					<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, <>4__this.roundRestartDelay.Value));
					<>1__state = 5;
					return true;
				}
				goto IL_0321;
			case 5:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.WaitForRoundEndPresentationCompleteRoutine("BeforeNextVote"));
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				goto IL_0321;
			case 7:
				<>1__state = -1;
				<>4__this.TriggerFinalWinnersByScore();
				<>4__this.FullGameEndCleanup(startProtection: true);
				<>4__this.ClearRoundResultPodiums();
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 8;
				return true;
			case 8:
				<>1__state = -1;
				goto IL_0416;
			case 9:
				{
					<>1__state = -1;
					<>4__this.gameState = GameState.Idle;
					return false;
				}
				IL_035a:
				if (<>4__this.gameStart.Value && !<>4__this.finalEndingTriggered)
				{
					<>4__this.gameState = GameState.GameEnding;
					<>4__this.SyncScoresToAll();
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.ShowFinalScoreboardRoutine(7f));
					<>1__state = 7;
					return true;
				}
				goto IL_0416;
				IL_0321:
				<>8__2 = null;
				goto IL_0329;
				IL_0416:
				<>4__this.mainGameRoutine = null;
				<>4__this.TurnOffAllStartTriggers();
				<>4__this.ClearArena();
				<>2__current = null;
				<>1__state = 9;
				return true;
				IL_0329:
				if (<>4__this.gameStart.Value && <>4__this.mainRoundPlayedCount < <roundsToPlay>5__1)
				{
					<>8__2 = new <>c__DisplayClass881_0();
					<>8__2.roundType = RoundGameType.CloudDynamite;
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.RunRoundVoteSelectionRoutine(<>4__this.mainRoundPlayedCount + 1, <roundsToPlay>5__1, delegate(RoundGameType selected)
					{
						<>8__2.roundType = selected;
					}));
					<>1__state = 2;
					return true;
				}
				goto IL_035a;
			}
		}

		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 <CloudWarningTintRoutine>d__1259 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public float warningSeconds;

		public Plugin <>4__this;

		private Color <yellow>5__1;

		private Color <orange>5__2;

		private Color <red>5__3;

		private float <total>5__4;

		private float <step>5__5;

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

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

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

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

		private bool MoveNext()
		{
			//IL_006a: 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_0089: 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_00a8: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_025f: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)obj == (Object)null)
				{
					return false;
				}
				<yellow>5__1 = new Color(1f, 0.92f, 0.02f, 1f);
				<orange>5__2 = new Color(1f, 0.48f, 0.02f, 1f);
				<red>5__3 = new Color(1f, 0.03f, 0.01f, 1f);
				if (warningSeconds < 1f)
				{
					<>4__this.ApplyCloudWarningSolidMaterialToObjectLocal(obj, <orange>5__2, 2.6f);
					<>2__current = (object)new WaitForSeconds(Mathf.Max(0.05f, warningSeconds));
					<>1__state = 1;
					return true;
				}
				<total>5__4 = Mathf.Max(0.5f, warningSeconds);
				<step>5__5 = <total>5__4 / 3f;
				<>4__this.ApplyCloudWarningSolidMaterialToObjectLocal(obj, <yellow>5__1, 1.8f);
				<>2__current = (object)new WaitForSeconds(<step>5__5);
				<>1__state = 2;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)obj != (Object)null)
				{
					<>4__this.activeCloudWarningTintRoutines.Remove(obj);
				}
				return false;
			case 2:
				<>1__state = -1;
				if ((Object)(object)obj == (Object)null)
				{
					return false;
				}
				<>4__this.ApplyCloudWarningSolidMaterialToObjectLocal(obj, <orange>5__2, 2.4f);
				<>2__current = (object)new WaitForSeconds(<step>5__5);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				if ((Object)(object)obj == (Object)null)
				{
					return false;
				}
				<>4__this.ApplyCloudWarningSolidMaterialToObjectLocal(obj, <red>5__3, 3f);
				<>2__current = (object)new WaitForSeconds(<step>5__5);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				if ((Object)(object)obj != (Object)null)
				{
					<>4__this.ApplyCloudWarningSolidMaterialToObjectLocal(obj, <red>5__3, 3.2f);
					<>4__this.activeCloudWarningTintRoutines.Remove(obj);
				}
				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 <DeleteMarkedTileAfterDelayRoutine>d__1246 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ArenaTile tile;

		public float delay;

		public Plugin <>4__this;

		private Vector3 <p>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//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;
				if (tile != null && (Object)(object)tile.obj != (Object)null)
				{
					<>4__this.ApplyOrangeWarningTintToTileLocal(tile);
					if (PhotonNetwork.InRoom && <>4__this.IsHostOrOffline())
					{
						<p>5__1 = tile.position;
						<>4__this.RaiseSimpleEvent(112, new object[4]
						{
							<p>5__1.x,
							<p>5__1.y,
							<p>5__1.z,
							Mathf.Max(0.5f, delay)
						}, (ReceiverGroup)0);
					}
				}
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, delay));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.pendingStandingTileDeletes.Remove(tile);
				if (<>4__this.gameState != GameState.Running)
				{
					return false;
				}
				if (tile == null || (Object)(object)tile.obj == (Object)null)
				{
					return false;
				}
				if (!<>4__this.activeTiles.Contains(tile))
				{
					return false;
				}
				<>4__this.PlayCloudDisappearSound();
				if (PhotonNetwork.InRoom && <>4__this.IsHostOrOffline())
				{
					<>4__this.RaiseSimpleEvent(114, Array.Empty<object>(), (ReceiverGroup)0);
				}
				<>4__this.RemoveTile(tile);
				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 <DeleteRound1MarkedTileAfterWarningRoutine>d__1237 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ArenaTile tile;

		public float warningSeconds;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, warningSeconds));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.DeleteRound1MarkedTileNow(tile);
				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 <DeleteThrownFrisbeeAfterDelayRoutine>d__1321 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Item item;

		public Plugin <>4__this;

		private Character <parentCharacter>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Mathf.Max(1f, <>4__this.thrownFrisbeeDeleteSeconds.Value));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)item == (Object)null)
				{
					return false;
				}
				try
				{
					<parentCharacter>5__1 = ((Component)item).GetComponentInParent<Character>();
					if ((Object)(object)<parentCharacter>5__1 != (Object)null)
					{
						return false;
					}
					<parentCharacter>5__1 = null;
				}
				catch
				{
				}
				<>4__this.DestroyItemObject(((Component)item).gameObject);
				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 <DestroyObjectAfterSecondsRoutine>d__1264 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public float seconds;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, seconds));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)obj != (Object)null)
				{
					Object.Destroy((Object)(object)obj);
				}
				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 <DestroyPodiumTeleportTestObjectAfterSecondsRoutine>d__1267 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public float seconds;

		public Plugin <>4__this;

		private PhotonView <view>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, seconds));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				if ((Object)(object)this.obj == (Object)null)
				{
					return false;
				}
				try
				{
					<>4__this.podiumTeleportTestObjects.Remove(this.obj);
				}
				catch
				{
				}
				try
				{
					<view>5__1 = this.obj.GetComponent<PhotonView>();
					if ((Object)(object)<view>5__1 != (Object)null && PhotonNetwork.InRoom)
					{
						if (<view>5__1.IsMine || <>4__this.IsHostOrOffline())
						{
							PhotonNetwork.Destroy(this.obj);
						}
						else
						{
							Object.Destroy((Object)(object)this.obj);
						}
					}
					else
					{
						Object.Destroy((Object)(object)this.obj);
					}
					<view>5__1 = null;
				}
				catch
				{
					try
					{
						Object.Destroy((Object)(object)this.obj);
					}
					catch
					{
					}
				}
				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 <DisableBeachObjectsDelayedRoutine>d__833 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>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
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(3f);
				<>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 <DynamiteGiveRoutine>d__1312 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private List<Character>.Enumerator <>s__1;

		private Character <character>5__2;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = default(List<Character>.Enumerator);
			<character>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.gameState == GameState.Running)
			{
				<>s__1 = <>4__this.alivePlayers.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<character>5__2 = <>s__1.Current;
						if ((Object)(object)<character>5__2 == (Object)null)
						{
							continue;
						}
						if (<>4__this.HasDynamiteInInventory(<character>5__2))
						{
							<>4__this.CancelPendingDynamiteGive(<character>5__2);
							continue;
						}
						if (!<>4__this.dynamiteDelayRoutines.ContainsKey(<character>5__2))
						{
							<>4__this.dynamiteDelayRoutines[<character>5__2] = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.GiveDynamiteAfterMissingDelayRoutine(<character>5__2));
						}
						<character>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Character>.Enumerator);
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0.1f, <>4__this.dynamiteCheckInterval.Value));
				<>1__state = 1;
				return true;
			}
			<>4__this.ClearPendingDynamiteRoutines();
			<>4__this.EndRhythmRoundLocal();
			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 <EnsureRoundResultPodiumsExistRoutine>d__1273 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private bool <missing>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 <EnsureRoundResultPodiumsExistRoutine>d__1273(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

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

		private bool MoveNext()
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (!<>4__this.IsHostOrOffline())
				{
					return false;
				}
				<missing>5__1 = <>4__this.roundResultPodiumObjects.Count < RoundResultPodiumSpawnPositions.Length;
				if (!<missing>5__1)
				{
					<i>5__2 = 0;
					while (<i>5__2 < RoundResultPodiumSpawnPositions.Length)
					{
						if (<i>5__2 >= <>4__this.roundResultPodiumObjects.Count || (Object)(object)<>4__this.roundResultPodiumObjects[<i>5__2] == (Object)null)
						{
							<missing>5__1 = true;
							break;
						}
						<i>5__2++;
					}
				}
				if (!<missing>5__1)
				{
					return false;
				}
				((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)"[TeleportGuard] Result podiums missing before round-end teleport. Respawning podiums now.");
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.SpawnRoundResultPodiumsForGameRoutine());
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 2;
				return true;
			case 2:
				<>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 <FinishCurrentRoundRoutine>d__1046 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string reason;

		public Plugin <>4__this;

		private string <blockReasonAfterDelay>5__1;

		private bool <allowDeadReviveThisRoundEnd>5__2;

		private float <notBefore>5__3;

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

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

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

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

		private bool MoveNext()
		{
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Expected O, but got Unknown
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Expected O, but got Unknown
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Expected O, but got Unknown
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (<>4__this.IsRoundStartFinishGuardActive())
				{
					((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[RoundGuard] Finish coroutine delayed during round start guard. reason=" + reason + ", type=" + <>4__this.currentRoundType));
					<notBefore>5__3 = <>4__this.roundStartFinishGuardUntil;
					goto IL_00d7;
				}
				goto IL_00fa;
			case 1:
				<>1__state = -1;
				goto IL_00d7;
			case 2:
				<>1__state = -1;
				<>4__this.roundResultPanelActive = false;
				<>4__this.roundResultPanelForcedLines = null;
				<>4__this.roundResultPanelForcedTitle = "";
				<allowDeadReviveThisRoundEnd>5__2 = <>4__this.ShouldReviveDeadPlayersAtRoundEnd(<>4__this.currentRoundType);
				<>4__this.CleanupRoundEndStateForAllPlayers(<allowDeadReviveThisRoundEnd>5__2);
				<>2__current = (object)new WaitForSeconds(0.25f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.EnsureRoundResultPodiumsExistRoutine());
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.TeleportRoundPlayersToRoundResultPodiums(<allowDeadReviveThisRoundEnd>5__2);
				<>4__this.ResetLocalMovementLockAnchor();
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PlayLocalRoundEndEmoteSequenceRoutine());
				<>1__state = 6;
				return true;
			case 6:
				<>1__state = -1;
				<>4__this.ShowAutoScoreboardAfterRoundEnd();
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 7;
				return true;
			case 7:
				{
					<>1__state = -1;
					if (<>4__this.currentRoundIsTestMode)
					{
						<>4__this.gameState = GameState.Idle;
						<>4__this.TurnOffAllStartTriggers();
						<>4__this.ClearArena();
					}
					else
					{
						<>4__this.gameState = GameState.Idle;
					}
					<>4__this.roundFinishInProgress = false;
					<>4__this.flareReadyActive = false;
					<>4__this.flareReadyLocalConfirmed = false;
					<>4__this.flareReadyThirdPersonLockUntil = -999f;
					<>4__this.flareReadyByActor.Clear();
					<>4__this.flareReadyActorOrder.Clear();
					<>4__this.flareReadyActorNames.Clear();
					if (<>4__this.flareReadyRoutine != null)
					{
						try
						{
							((MonoBehaviour)<>4__this).StopCoroutine(<>4__this.flareReadyRoutine);
						}
						catch
						{
						}
						<>4__this.flareReadyRoutine = null;
					}
					<>4__this.roundEndStartedAt = -1f;
					<>4__this.currentRoundHardTimeoutAt = -1f;
					<>4__this.roundEndPresentationComplete = true;
					<>4__this.finishRoundRoutineHandle = null;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[RoundEnd] FinishCurrentRoundRoutine EXIT reason=" + reason + ", type=" + <>4__this.currentRoundType));
					return false;
				}
				IL_00d7:
				if (<>4__this.gameState == GameState.Running && Time.time < <notBefore>5__3)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_00fa;
				IL_00fa:
				if (!<>4__this.CanFinishCurrentRoundNow(reason, out <blockReasonAfterDelay>5__1))
				{
					((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[RoundGuard] Finish coroutine blocked after recheck. reason=" + reason + ", block=" + <blockReasonAfterDelay>5__1 + ", type=" + <>4__this.currentRoundType.ToString() + ", alive=" + <>4__this.alivePlayers.Count + ", players=" + <>4__this.roundPlayers.Count));
					<>4__this.finishRoundRoutineHandle = null;
					return false;
				}
				if (<>4__this.roundFinishInProgress)
				{
					return false;
				}
				if (<>4__this.gameState != GameState.Running && <>4__this.gameState != GameState.RoundEnding)
				{
					((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[RoundEnd] FinishCurrentRoundRoutine rejected. reason=" + reason + ", state=" + <>4__this.gameState.ToString() + ", type=" + <>4__this.currentRoundType));
					<>4__this.finishRoundRoutineHandle = null;
					return false;
				}
				<>4__this.EndRoundStartFinishGuard("FinishCurrentRoundRoutine");
				<>4__this.roundFinishInProgress = true;
				<>4__this.roundEndPresentationComplete = false;
				<>4__this.gameState = GameState.RoundEnding;
				<>4__this.roundEndStartedAt = Time.time;
				<>4__this.currentRoundHardTimeoutAt = -1f;
				<>4__this.round6AnswerGaugeActive = false;
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[RoundEnd] FinishCurrentRoundRoutine ENTER reason=" + reason + ", type=" + <>4__this.currentRoundType.ToString() + ", alive=" + <>4__this.alivePlayers.Count + ", eliminated=" + <>4__this.eliminatedPlayers.Count));
				<>4__this.StopRoundRoutines();
				if (<>4__this.currentRoundType == RoundGameType.CloudDynamite)
				{
					<>4__this.BroadcastForceClearAllPlayerInventories("CloudDynamiteRoundEnd");
				}
				<>4__this.AddCurrentRoundScoresToTotal();
				<>4__this.SyncScoresToAll();
				<>4__this.RaiseSimpleEvent(106, <>4__this.BuildRoundEndEventData(reason), (ReceiverGroup)0);
				<>4__this.centerNoticeText = "";
				<>4__this.centerNoticeUntil = 0f;
				<>4__this.ShowRoundResultPanelForCurrentRound(4f);
				<>4__this.roundBetweenMovementLockUntil = Mathf.Max(<>4__this.roundBetweenMovementLockUntil, Time.time + 12.2f);
				<>2__current = (object)new WaitForSeconds(4f);
				<>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();
		}
	}

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

		private object <>2__current;

		public Plugin <>4__this;

		private object[] <data>5__1;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.flareReadySequence++;
				if (<>4__this.flareReadySequence <= 0)
				{
					<>4__this.flareReadySequence = 1;
				}
				<>4__this.BuildFlareReadyActorList();
				<data>5__1 = <>4__this.BuildFlareReadyStartEventData();
				<>4__this.ApplyFlareReadyStartLocal(<data>5__1);
				<>4__this.RaiseMiniGameEvent(138, <data>5__1, (ReceiverGroup)0);
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[FlareReady] Ready phase started. seq=" + <>4__this.flareReadySequence + " players=" + <>4__this.flareReadyActorOrder.Count));
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.flareReadyActive)
			{
				if (<>4__this.gameState != 0 || <>4__this.mainGameRoutine != null || <>4__this.singleRoundTestRunning)
				{
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("[FlareReady] Ready phase cancelled by state. gameState=" + <>4__this.gameState));
					<>4__this.ApplyFlareReadyEndLocal(new object[2] { <>4__this.flareReadySequence, false });
					<>4__this.RaiseMiniGameEvent(140, new object[2] { <>4__this.flareReadySequence, false }, (ReceiverGroup)0);
					<>4__this.flareReadyRoutine = null;
					return false;
				}
				if (!<>4__this.AreAllFlareReadyActorsReady())
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
			}
			((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[FlareReady] All players ready. Starting Party Games.");
			<>4__this.ApplyFlareReadyEndLocal(new object[2] { <>4__this.flareReadySequence, true });
			<>4__this.RaiseMiniGameEvent(140, new object[2] { <>4__this.flareReadySequence, true }, (ReceiverGroup)0);
			<>4__this.flareReadyRoutine = null;
			<>4__this.TryStartAutoGame();
			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 <ForceClearSkeletonForSeconds>d__927 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character character;

		public float seconds;

		public Plugin <>4__this;

		private float <end>5__1;

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

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

		[DebuggerHidden]
		public <ForceClearSkeletonForSeconds>d__927(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;
				<end>5__1 = Time.time + Mathf.Max(0.1f, seconds);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)character != (Object)null && Time.time < <end>5__1)
			{
				try
				{
					if ((Object)(object)character.data != (Object)null)
					{
						character.data.SetSkeleton(false);
						character.data.dead = false;
						character.data.passedOut = false;
						character.data.fullyPassedOut = false;
					}
				}
				catch
				{
				}
				<>2__current = null;
				<>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 <ForceShelfInstalledFinalFrameDelayed>d__1073 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.ForceShelfInstalledFinalFrame(obj);
				<>2__current = (object)new WaitForSeconds(0.05f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.ForceShelfInstalledFinalFrame(obj);
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.ForceShelfInstalledFinalFrame(obj);
				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 <FrisbeeMaintainRoutine>d__1355 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private List<Character>.Enumerator <>s__1;

		private Character <character>5__2;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = default(List<Character>.Enumerator);
			<character>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.gameState == GameState.Running)
			{
				<>s__1 = <>4__this.alivePlayers.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<character>5__2 = <>s__1.Current;
						if ((Object)(object)<character>5__2 != (Object)null)
						{
							<>4__this.ForceFrisbeeSlotOne(<character>5__2);
						}
						<character>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Character>.Enumerator);
				<>2__current = (object)new WaitForSeconds(1f);
				<>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 <GiveDynamiteAfterMissingDelayRoutine>d__1313 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character character;

		public Plugin <>4__this;

		private float <delay>5__1;

		private float <timer>5__2;

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

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

		[DebuggerHidden]
		public <GiveDynamiteAfterMissingDelayRoutine>d__1313(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;
				<delay>5__1 = Mathf.Max(0.1f, <>4__this.dynamiteMissingDelay.Value);
				if (<>4__this.IsLocalCharacter(character))
				{
					<>4__this.showDynamiteChargeBar = true;
					<>4__this.localDynamiteChargeActive = true;
					<>4__this.dynamiteChargeStartTime = Time.time;
					<>4__this.dynamiteChargeDuration = <delay>5__1;
				}
				<timer>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<timer>5__2 < <delay>5__1)
			{
				if ((Object)(object)character == (Object)null || <>4__this.gameState != GameState.Running || !<>4__this.alivePlayers.Contains(character))
				{
					if (<>4__this.IsLocalCharacter(character))
					{
						<>4__this.showDynamiteChargeBar = false;
						<>4__this.localDynamiteChargeActive = false;
					}
					return false;
				}
				if (<>4__this.HasDynamiteInInventory(character))
				{
					if (<>4__this.IsLocalCharacter(character))
					{
						<>4__this.showDynamiteChargeBar = false;
						<>4__this.localDynamiteChargeActive = false;
					}
					<>4__this.dynamiteDelayRoutines.Remove(character);
					return false;
				}
				<timer>5__2 += Time.deltaTime;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if (<>4__this.IsLocalCharacter(character))
			{
				<>4__this.showDynamiteChargeBar = false;
				<>4__this.localDynamiteChargeActive = false;
			}
			if ((Object)(object)character == (Object)null || <>4__this.gameState != GameState.Running || !<>4__this.alivePlayers.Contains(character))
			{
				return false;
			}
			if (!<>4__this.HasDynamiteInInventory(character))
			{
				<>4__this.GiveLitDynamite(character);
			}
			<>4__this.dynamiteDelayRoutines.Remove(character);
			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 <LogTeleportPositionDelayedRoutine>d__1303 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character character;

		public string source;

		public Vector3 target;

		public float delay;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_007d: 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(Mathf.Max(0f, delay));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.LogTeleportPositionNow(character, source + "+" + delay.ToString("0.00") + "s", target);
				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 <LowerTileObjectRoutine>d__1231 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public float targetY;

		public float duration;

		public Plugin <>4__this;

		private Vector3 <start>5__1;

		private Vector3 <end>5__2;

		private float <t>5__3;

		private float <a>5__4;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b7: 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_00c8: 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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)obj == (Object)null)
				{
					return false;
				}
				<start>5__1 = obj.transform.position;
				<end>5__2 = new Vector3(<start>5__1.x, targetY, <start>5__1.z);
				<t>5__3 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)obj != (Object)null && <t>5__3 < duration)
			{
				<t>5__3 += Time.deltaTime;
				<a>5__4 = Mathf.Clamp01(<t>5__3 / duration);
				<>4__this.SetTileObjectWorldPosition(obj, Vector3.Lerp(<start>5__1, <end>5__2, <a>5__4));
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			if ((Object)(object)obj != (Object)null)
			{
				<>4__this.SetTileObjectWorldPosition(obj, <end>5__2);
				<>4__this.activeTileLowerRoutines.Remove(obj);
			}
			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 <PlayClientRoundEndPresentationRoutine>d__1048 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.ShowRoundResultPanelForCurrentRound(4f);
				<>4__this.roundBetweenMovementLockUntil = Mathf.Max(<>4__this.roundBetweenMovementLockUntil, Time.time + 12.2f);
				<>2__current = (object)new WaitForSeconds(4f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.roundResultPanelActive = false;
				<>4__this.roundResultPanelForcedLines = null;
				<>4__this.roundResultPanelForcedTitle = "";
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PlayLocalRoundEndEmoteSequenceRoutine());
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.ShowAutoScoreboardAfterRoundEnd();
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.roundEndEmoteRoutine = 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();
		}
	}

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

		private object <>2__current;

		public Plugin <>4__this;

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

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

		[DebuggerHidden]
		public <PlayLocalRoundEndEmoteDelayed>d__1049(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;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.PlayClientRoundEndPresentationRoutine());
				<>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 <PlayLocalRoundEndEmoteSequenceRoutine>d__1050 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private string <animName>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<animName>5__1 = <>4__this.GetLocalRoundEndEmoteAnimationFromScores();
				if (!string.IsNullOrEmpty(<animName>5__1))
				{
					<>4__this.PlayLocalRoundEndEmote(<animName>5__1);
					<>4__this.StartRoundEndDedicatedOverlayCameraForSeconds(5f);
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				<>4__this.PlayLocalRoundEndEmote(<animName>5__1);
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				break;
			}
			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 <PodiumTeleportComparisonTestRoutine>d__1266 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public bool useAssisted;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			if (<>1__state != 0)
			{
				return false;
			}
			<>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 <PodiumTeleportStabilizeRoutine>d__1305 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Character character;

		public Vector3 target;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			if (<>1__state != 0)
			{
				return false;
			}
			<>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 <RemoveEffectObjectsRoutine>d__1396 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject root;

		public Plugin <>4__this;

		private float <duration>5__1;

		private float <timer>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)root == (Object)null)
				{
					return false;
				}
				<duration>5__1 = Mathf.Clamp(<>4__this.effectCleanupDuration.Value, 0.1f, 5f);
				<timer>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<timer>5__2 < <duration>5__1)
			{
				if ((Object)(object)root == (Object)null)
				{
					return false;
				}
				<>4__this.RemoveEffectObjectsNow(root);
				<timer>5__2 += 0.1f;
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}
			if ((Object)(object)root != (Object)null)
			{
				<>4__this.RemoveEffectObjectsNow(root);
			}
			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 <RescueHookMaintainRoutine>d__1346 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private List<Character>.Enumerator <>s__1;

		private Character <character>5__2;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>s__1 = default(List<Character>.Enumerator);
			<character>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<>4__this.gameState == GameState.Running)
			{
				<>s__1 = <>4__this.alivePlayers.GetEnumerator();
				try
				{
					while (<>s__1.MoveNext())
					{
						<character>5__2 = <>s__1.Current;
						if ((Object)(object)<character>5__2 != (Object)null)
						{
							<>4__this.ForceRescueHookToPlayer(<character>5__2);
						}
						<character>5__2 = null;
					}
				}
				finally
				{
					((IDisposable)<>s__1).Dispose();
				}
				<>s__1 = default(List<Character>.Enumerator);
				<>4__this.ConfigureAllRescueHooksForArenaMode();
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0.1f, <>4__this.rescueHookMaintainInterval.Value));
				<>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 <Round1OuterCloudCollapseRoutine>d__1234 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

		private float <startDelay>5__1;

		private float <startTime>5__2;

		private List<ArenaTile> <rowTiles>5__3;

		private float <warningSeconds>5__4;

		private int <i>5__5;

		private ArenaTile <tile>5__6;

		private Vector3 <p>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 <Round1OuterCloudCollapseRoutine>d__1234(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

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

		private bool MoveNext()
		{
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: 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.standingTileDeleteStarted = false;
				<startDelay>5__1 = Mathf.Max(0f, (<>4__this.round1EdgeCollapseStartDelay != null) ? <>4__this.round1EdgeCollapseStartDelay.Value : 3f);
				<startTime>5__2 = Time.time + <startDelay>5__1;
				goto IL_00a2;
			case 1:
				<>1__state = -1;
				goto IL_00a2;
			case 2:
				<>1__state = -1;
				break;
			case 3:
				{
					<>1__state = -1;
					<i>5__8 = 0;
					while (<i>5__8 < <rowTiles>5__3.Count)
					{
						<>4__this.DeleteRound1MarkedTileNow(<rowTiles>5__3[<i>5__8]);
						<i>5__8++;
					}
					<rowTiles>5__3 = null;
					break;
				}
				IL_00a2:
				if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.CloudDynamite && Time.time < <startTime>5__2)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.standingTileDeleteStarted = true;
				break;
			}
			if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.CloudDynamite)
			{
				<>4__this.ClearDeadTiles();
				if (<>4__this.activeTiles.Count != 0)
				{
					<rowTiles>5__3 = <>4__this.PickCurrentOuterCloudTileRowForCollapse();
					if (<rowTiles>5__3 == null || <rowTiles>5__3.Count == 0)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<warningSeconds>5__4 = <>4__this.GetRound1EdgeCollapseWarningSeconds();
					<i>5__5 = 0;
					while (<i>5__5 < <rowTiles>5__3.Count)
					{
						<tile>5__6 = <rowTiles>5__3[<i>5__5];
						if (<tile>5__6 != null && !((Object)(object)<tile>5__6.obj == (Object)null) && !<>4__this.pendingStandingTileDeletes.Contains(<tile>5__6))
						{
							<>4__this.pendingStandingTileDeletes.Add(<tile>5__6);
							<>4__this.StartCloudWarningTintToTileLocal(<tile>5__6, <warningSeconds>5__4);
							if (PhotonNetwork.InRoom && <>4__this.IsHostOrOffline())
							{
								<p>5__7 = <tile>5__6.position;
								<>4__this.RaiseSimpleEvent(112, new object[4] { <p>5__7.x, <p>5__7.y, <p>5__7.z, <warningSeconds>5__4 }, (ReceiverGroup)0);
							}
							<tile>5__6 = null;
						}
						<i>5__5++;
					}
					<>2__current = (object)new WaitForSeconds(Mathf.Max(0f, <warningSeconds>5__4));
					<>1__state = 3;
					return true;
				}
			}
			<>4__this.standingTileDeleteStarted = false;
			<>4__this.standingTileDeleteRoutine = 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();
		}
	}

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

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0.1f, <>4__this.coconutSpawnInterval.Value));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<>4__this.gameState == GameState.Running)
			{
				<>4__this.SpawnCoconutOnRandomExistingCloudTile();
				<>2__current = (object)new WaitForSeconds(Mathf.Max(0.1f, <>4__this.coconutSpawnInterval.Value));
				<>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();
		}
	}

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

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			if (<>1__state != 0)
			{
				return false;
			}
			<>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 <Round5PoppyTransferMonitorRoutine>d__1329 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			if (<>1__state != 0)
			{
				return false;
			}
			<>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 <Round5ScoreRoutine>d__1326 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			if (<>1__state != 0)
			{
				return false;
			}
			<>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 <Round9WrongThenNextTurnRoutine>d__1155 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Plugin <>4__this;

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

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

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

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

		private bool MoveNext()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.round9WrongRevealUntil = Time.time + 0.7f;
				<>2__current = (object)new WaitForSeconds(0.7f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.round9FirstPickIndex = -1;
				<>4__this.round9TempRevealIndex = -1;
				<>4__this.round9WrongRevealUntil = -1f;
				<>4__this.round9WrongRevealRoutine = 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();
		}
	}

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

		private object <>2__current;

		public RoundGameType roundType;

		public Plugin <>4__this;

		private float <teleportWaitStart>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0105: 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_00b5: 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_00d1: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<teleportWaitStart>5__1 = Time.time;
				goto IL_005b;
			case 1:
				<>1__state = -1;
				goto IL_005b;
			case 2:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("Start", 0.8f, new Color(1f, 0.68f, 0.38f, 1f), thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.8f);
				<>1__state = 3;
				return true;
			case 3:
				{
					<>1__state = -1;
					return false;
				}
				IL_005b:
				if (<>4__this.activeTiles.Count == 0 && Time.time < <teleportWaitStart>5__1 + 2f)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.TeleportRoundPlayersToSafeArenaTiles(roundType);
				<>4__this.gameState = GameState.RoundStarting;
				<>4__this.RaiseCenterNoticeToAll("Ready", 3f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(3f);
				<>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();
		}
	}

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

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private string <sequence>5__1;

		private float <limit>5__2;

		private float <allSubmittedAt>5__3;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.arrowRoundSubmissions.Clear();
				<sequence>5__1 = <>4__this.BuildRound3GridTargetSequence();
				<>4__this.BeginArrowRoundLocal(<sequence>5__1);
				<>4__this.RaiseMiniGameEvent(103, new object[1] { <sequence>5__1 }, (ReceiverGroup)0);
				<limit>5__2 = Mathf.Max(3f, <>4__this.arrowRoundTimeLimit.Value);
				<allSubmittedAt>5__3 = -1f;
				goto IL_019c;
			case 1:
				<>1__state = -1;
				goto IL_019c;
			case 2:
				{
					<>1__state = -1;
					return false;
				}
				IL_019c:
				if (<>4__this.gameState == GameState.Running && Time.time < <>4__this.arrowRoundStartLocalTime + <limit>5__2 && (!testMode || <>4__this.IsRoundToggleStillOn(<>4__this.currentRoundType)) && (testMode || <>4__this.gameStart.Value))
				{
					if (<>4__this.arrowRoundSubmissions.Count >= Mathf.Max(1, <>4__this.roundPlayers.Count))
					{
						if (<allSubmittedAt>5__3 < 0f)
						{
							<allSubmittedAt>5__3 = Time.time;
						}
						if (Time.time >= <allSubmittedAt>5__3 + 1.25f)
						{
							goto IL_01cf;
						}
					}
					else
					{
						<allSubmittedAt>5__3 = -1f;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_01cf;
				IL_01cf:
				<>4__this.EndArrowRoundLocal();
				<>4__this.AwardArrowRoundScores();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("GRID_STAR_FINISH"));
				<>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();
		}
	}

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

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private string <sequence>5__1;

		private float[] <noteOffsets>5__2;

		private float <start>5__3;

		private float <minimumLimit>5__4;

		private float <limit>5__5;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00ed: 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.rhythmRoundSubmissions.Clear();
				<>4__this.rhythmRoundProgressByActor.Clear();
				<>4__this.rhythmCenterResultPanelActive = false;
				<>4__this.rhythmCenterResultPanelUntil = -1f;
				<sequence>5__1 = <>4__this.BuildRandomArrowSequence(30);
				<noteOffsets>5__2 = <>4__this.BuildRandomRhythmNoteTargetOffsets(<sequence>5__1.Length);
				<>4__this.BeginRhythmRoundLocal(<sequence>5__1, <noteOffsets>5__2);
				<>4__this.RaiseMiniGameEvent(110, new object[2] { <sequence>5__1, <noteOffsets>5__2 }, (ReceiverGroup)0);
				<>4__this.ShowCenterNotice("WASD 리듬", 1.2f, Color.white, thickRounded: true);
				<start>5__3 = Time.time;
				<minimumLimit>5__4 = Mathf.Max(4f, <>4__this.rhythmNoteTravelSeconds.Value + <>4__this.GetRhythmLastNoteTargetOffset() + 2f);
				<limit>5__5 = Mathf.Max(<minimumLimit>5__4, <>4__this.rhythmRoundTimeLimit.Value);
				goto IL_01f7;
			case 1:
				<>1__state = -1;
				goto IL_01f7;
			case 2:
				{
					<>1__state = -1;
					return false;
				}
				IL_01f7:
				if (<>4__this.gameState == GameState.Running && Time.time - <start>5__3 < <limit>5__5 && (!testMode || <>4__this.IsRoundToggleStillOn(<>4__this.currentRoundType)) && (testMode || <>4__this.gameStart.Value) && <>4__this.rhythmRoundSubmissions.Count < Mathf.Max(1, <>4__this.roundPlayers.Count))
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.SubmitRhythmResultIfNeeded();
				<>4__this.EndRhythmRoundLocal();
				<>4__this.AwardRhythmRoundScores();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("RHYTHM_FINISH"));
				<>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();
		}
	}

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

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private float <waitStart>5__1;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00ba: 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_00d6: Expected O, but got Unknown
			//IL_00f6: 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_0112: Expected O, but got Unknown
			//IL_0132: 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_014e: Expected O, but got Unknown
			//IL_016e: 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_018a: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.EndRound10HalliGalliLocal();
				<>4__this.round10ScoresByActor.Clear();
				<>4__this.currentRoundScores.Clear();
				<>4__this.RefreshActorNamesFromCharacters();
				<>4__this.RaiseCenterNoticeToAll("할리갈리", 1.2f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(1.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("3", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("2", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("1", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("시작", 0.45f, new Color(1f, 0.68f, 0.38f, 1f), thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.05f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				if (<>4__this.IsHostOrOffline())
				{
					<>4__this.BeginRound10HalliGalliAsHost();
				}
				<waitStart>5__1 = Time.time;
				goto IL_0229;
			case 6:
				<>1__state = -1;
				goto IL_0229;
			case 7:
				<>1__state = -1;
				goto IL_0332;
			case 8:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("HALLI_GALLI_FINISH"));
				<>1__state = 9;
				return true;
			case 9:
				{
					<>1__state = -1;
					return false;
				}
				IL_0229:
				if (!<>4__this.round10HalliActive && Time.time < <waitStart>5__1 + 3f)
				{
					<>2__current = null;
					<>1__state = 6;
					return true;
				}
				goto IL_0332;
				IL_0332:
				if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.HalliGalli && (!testMode || <>4__this.IsRoundToggleStillOn(RoundGameType.HalliGalli)) && (testMode || <>4__this.gameStart.Value))
				{
					if (<>4__this.IsHostOrOffline() && <>4__this.round10HalliActive && !<>4__this.round10BellLocked && Time.time >= <>4__this.round10NextDrawTime && <>4__this.round10SuccessCount < 10)
					{
						<>4__this.DrawNextRound10CardAsHost();
					}
					if (<>4__this.round10SuccessCount < 10)
					{
						<>2__current = null;
						<>1__state = 7;
						return true;
					}
				}
				if (<>4__this.round10SuccessCount >= 10)
				{
					<>4__this.round10Completed = true;
				}
				<>4__this.AwardRound10RankScoresFromSuccessCounts();
				<>4__this.SyncScoresToAll();
				<>4__this.EndRound10HalliGalliLocal(resetCompletedFlag: false);
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 8;
				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 <RunRound11DinoRunRoutine>d__1089 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private float[] <obstacleTimes>5__1;

		private int[] <obstacleTypes>5__2;

		private int <nonce>5__3;

		private float <travel>5__4;

		private float <limit>5__5;

		private float <start>5__6;

		private float <earliestFinishTime>5__7;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.LogRound11Debug("RunRound11DinoRunRoutine ENTER testMode=" + testMode + ", " + <>4__this.GetRound11StateString());
				<>4__this.EndRound11DinoLocal();
				<>4__this.round11DinoPassedByActor.Clear();
				<>4__this.round11DinoFailedByActor.Clear();
				<>4__this.round11DinoPenaltyByActor.Clear();
				<>4__this.round11DinoScoreByActor.Clear();
				<>4__this.round11DinoFinalSubmittedActors.Clear();
				<>4__this.currentRoundScores.Clear();
				<>4__this.BuildRound11DinoObstaclePattern(out <obstacleTimes>5__1, out <obstacleTypes>5__2);
				<nonce>5__3 = Random.Range(100000, 999999);
				<>4__this.BeginRound11DinoLocal(<obstacleTimes>5__1, <obstacleTypes>5__2, <nonce>5__3);
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)("Round 11 DinoRun started. Obstacles: " + ((<obstacleTimes>5__1 != null) ? <obstacleTimes>5__1.Length.ToString() : "0") + ", nonce: " + <nonce>5__3));
				<>4__this.LogRound11Debug("After BeginRound11DinoLocal " + <>4__this.GetRound11StateString());
				<>4__this.RaiseMiniGameEvent(134, new object[3] { <nonce>5__3, <obstacleTimes>5__1, <obstacleTypes>5__2 }, (ReceiverGroup)0);
				<travel>5__4 = <>4__this.GetRound11ObstacleTravelSeconds();
				<limit>5__5 = 3f + ((<obstacleTimes>5__1 != null && <obstacleTimes>5__1.Length != 0) ? <obstacleTimes>5__1[<obstacleTimes>5__1.Length - 1] : 28f) + <travel>5__4 + 2f;
				<start>5__6 = Time.unscaledTime;
				<earliestFinishTime>5__7 = <start>5__6 + 3f + Mathf.Max(4f, <travel>5__4 + 2.6f);
				goto IL_037a;
			case 1:
				<>1__state = -1;
				goto IL_037a;
			case 2:
				<>1__state = -1;
				goto IL_037a;
			case 3:
				{
					<>1__state = -1;
					return false;
				}
				IL_037a:
				if (<>4__this.round11DinoActive && <>4__this.currentRoundType == RoundGameType.DinoRun && Time.unscaledTime - <start>5__6 < <limit>5__5)
				{
					if (<>4__this.gameState != GameState.Running)
					{
						<>4__this.LogRound11Debug("RunLoop corrected gameState from " + <>4__this.gameState.ToString() + " to Running. " + <>4__this.GetRound11StateString());
						<>4__this.gameState = GameState.Running;
					}
					if (testMode || <>4__this.gameStart.Value)
					{
						if (<>4__this.HaveAllRound11DinoParticipantsSubmitted())
						{
							if (<>4__this.round11DinoGlobalEndAllowedTime > 0f && Time.unscaledTime < <>4__this.round11DinoGlobalEndAllowedTime)
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
							if (Time.unscaledTime >= <earliestFinishTime>5__7 || <>4__this.round11DinoGlobalEndAllowedTime > 0f)
							{
								goto IL_03b6;
							}
						}
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
				}
				goto IL_03b6;
				IL_03b6:
				<>4__this.LogRound11Debug("Loop EXIT before final submit. elapsed=" + (Time.unscaledTime - <start>5__6).ToString("0.00") + ", limit=" + <limit>5__5.ToString("0.00") + ", " + <>4__this.GetRound11StateString());
				if (!<>4__this.round11DinoActive || <>4__this.currentRoundType != RoundGameType.DinoRun)
				{
					((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("Round 11 DinoRun was interrupted before normal finish. State: " + <>4__this.gameState.ToString() + ", Type: " + <>4__this.currentRoundType));
					<>4__this.round11DinoAllowLocalEnd = true;
					<>4__this.EndRound11DinoLocal();
					return false;
				}
				<>4__this.SubmitRound11DinoResultIfNeeded(failed: false);
				<>4__this.AwardRound11DinoScores();
				<>4__this.round11DinoAllowLocalEnd = true;
				<>4__this.EndRound11DinoLocal();
				<>4__this.SyncScoresToAll();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("DINO_RUN_FINISH"));
				<>1__state = 3;
				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 <RunRound6ColorSurvivalRoutine>d__1194 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private int <cycle>5__1;

		private Round6CloudColor <targetColor>5__2;

		private float <answerWindowSeconds>5__3;

		private HashSet<int> <awardedActorsThisCycle>5__4;

		private float <endTime>5__5;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01de: 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_01fa: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Expected O, but got Unknown
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Expected O, but got Unknown
			//IL_012a: 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_0146: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.CaptureRound6OriginalStateForAllTiles();
				<cycle>5__1 = 0;
				goto IL_03a1;
			case 1:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("3", 0.85f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.85f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("2", 0.85f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.85f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("1", 0.85f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.85f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.AssignRound6RandomCloudColorsAndSync(<targetColor>5__2);
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<answerWindowSeconds>5__3 = <>4__this.GetRound6AnswerWindowSeconds();
				<>4__this.StartRound6AnswerGaugeToAll(<answerWindowSeconds>5__3, <targetColor>5__2);
				<awardedActorsThisCycle>5__4 = new HashSet<int>();
				<endTime>5__5 = Time.time + <answerWindowSeconds>5__3;
				goto IL_029d;
			case 6:
				<>1__state = -1;
				goto IL_029d;
			case 7:
				<>1__state = -1;
				if (<>4__this.gameState != GameState.Running || <>4__this.currentRoundType != RoundGameType.ColorCloudSurvival)
				{
					return false;
				}
				<>4__this.RestoreRound6AllTilesAndSync();
				<>2__current = (object)new WaitForSeconds(0.65f);
				<>1__state = 8;
				return true;
			case 8:
				<>1__state = -1;
				<awardedActorsThisCycle>5__4 = null;
				<cycle>5__1++;
				goto IL_03a1;
			case 9:
				{
					<>1__state = -1;
					break;
				}
				IL_029d:
				if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.ColorCloudSurvival && Time.time < <endTime>5__5)
				{
					<>2__current = null;
					<>1__state = 6;
					return true;
				}
				<>4__this.AwardRound6PlayersNearestTargetColorAtFinalMoment(<targetColor>5__2, <awardedActorsThisCycle>5__4);
				<>4__this.round6AnswerGaugeActive = false;
				<>4__this.SyncScoresToAll();
				<>4__this.ShowRound6PersonalResultNoticeToAll(<awardedActorsThisCycle>5__4);
				<>2__current = (object)new WaitForSeconds(0.85f);
				<>1__state = 7;
				return true;
				IL_03a1:
				if (<cycle>5__1 < 4)
				{
					if (<>4__this.gameState != GameState.Running || <>4__this.currentRoundType != RoundGameType.ColorCloudSurvival)
					{
						return false;
					}
					if (testMode)
					{
						if (!<>4__this.IsRoundToggleStillOn(RoundGameType.ColorCloudSurvival))
						{
							return false;
						}
					}
					else if (!<>4__this.gameStart.Value)
					{
						return false;
					}
					<targetColor>5__2 = <>4__this.PickRandomRound6TargetColor();
					<>4__this.RaiseCenterNoticeToAll(<>4__this.GetRound6ColorName(<targetColor>5__2), 1.2f, <>4__this.GetRound6ColorValue(<targetColor>5__2), thickRounded: true);
					<>2__current = (object)new WaitForSeconds(1.2f);
					<>1__state = 1;
					return true;
				}
				if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.ColorCloudSurvival)
				{
					<>4__this.LockRound6ScoresAtEnd();
					<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("ROUND6_ALL_CYCLES_DONE"));
					<>1__state = 9;
					return true;
				}
				break;
			}
			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 <RunRound7ButtonMashRoutine>d__1179 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public bool testMode;

		public Plugin <>4__this;

		private float <start>5__1;

		private float <limit>5__2;

		private float <allFinishedAt>5__3;

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

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

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

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

		private bool MoveNext()
		{
			//IL_0104: 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_0120: Expected O, but got Unknown
			//IL_0140: 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_017c: 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_0198: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.round7ProgressByActor.Clear();
				<>4__this.round7FinishTimes.Clear();
				<>4__this.round7RankByActor.Clear();
				<>4__this.round8PositionsByActor.Clear();
				<>4__this.round8StarsByActor.Clear();
				<>4__this.round8ParalyzedUntilByActor.Clear();
				<>4__this.ClearRound8ElectricCells();
				<>4__this.round8StarsEatenTotal = 0;
				<>4__this.EndRound7ButtonMashLocal();
				<>4__this.RefreshActorNamesFromCharacters();
				<>4__this.RaiseCenterNoticeToAll("달리기", 1.2f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(1.2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("3", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("2", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("1", 0.75f, Color.white, thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.75f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.RaiseCenterNoticeToAll("시작", 0.45f, new Color(1f, 0.68f, 0.38f, 1f), thickRounded: true);
				<>2__current = (object)new WaitForSeconds(0.05f);
				<>1__state = 5;
				return true;
			case 5:
				<>1__state = -1;
				<>4__this.BeginRound7ButtonMashLocal();
				<>4__this.RaiseMiniGameEvent(119, Array.Empty<object>(), (ReceiverGroup)0);
				<start>5__1 = Time.time;
				<limit>5__2 = Mathf.Max(5f, (<>4__this.round7TimeLimitSeconds != null) ? <>4__this.round7TimeLimitSeconds.Value : 20f);
				<allFinishedAt>5__3 = -1f;
				goto IL_0388;
			case 6:
				<>1__state = -1;
				goto IL_0388;
			case 7:
				{
					<>1__state = -1;
					return false;
				}
				IL_0388:
				if (<>4__this.gameState == GameState.Running && <>4__this.currentRoundType == RoundGameType.ButtonMashRace && (!testMode || <>4__this.IsRoundToggleStillOn(RoundGameType.ButtonMashRace)) && (testMode || <>4__this.gameStart.Value))
				{
					if (<allFinishedAt>5__3 < 0f && <>4__this.HaveAllRound7ParticipantsFinished())
					{
						<allFinishedAt>5__3 = Time.time;
					}
					if (<allFinishedAt>5__3 >= 0f)
					{
						if (!(Time.time >= <allFinishedAt>5__3 + 5f))
						{
							goto IL_0370;
						}
					}
					else if (!(Time.time - <start>5__1 >= <limit>5__2))
					{
						goto IL_0370;
					}
				}
				<>4__this.EndRound7ButtonMashLocal();
				<>4__this.AwardRound7ButtonMashScores();
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FinishCurrentRoundRoutine("BUTTON_MASH_FINISH"));
				<>1__state = 7;
				return true;
				IL_0370:
				<>2__curre