using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using RoR2;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SnowtimeComponents")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f93a40505933251ade42c302b6e56c94395e6e5c")]
[assembly: AssemblyProduct("SnowtimeComponents")]
[assembly: AssemblyTitle("SnowtimeComponents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[ExecuteAlways]
public class SetAmbientLightPrettyPlease : MonoBehaviour
{
	public bool setSkyboxMaterial;

	public bool setAmbientLightColor;

	public Material skyboxMaterial;

	public AmbientMode ambientMode;

	public float ambientIntensity;

	[ColorUsage(true, true)]
	public Color ambientSkyColor = Color.black;

	[ColorUsage(true, true)]
	public Color ambientEquatorColor = Color.black;

	[ColorUsage(true, true)]
	public Color ambientGroundColor = Color.black;

	public void Start()
	{
		ApplyLighting();
	}

	public void ApplyLighting()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		if (setAmbientLightColor)
		{
			RenderSettings.ambientMode = ambientMode;
			RenderSettings.ambientSkyColor = ambientSkyColor * ambientIntensity;
			RenderSettings.ambientEquatorColor = ambientEquatorColor * ambientIntensity;
			RenderSettings.ambientGroundColor = ambientGroundColor * ambientIntensity;
		}
		if (setSkyboxMaterial)
		{
			RenderSettings.skybox = skyboxMaterial;
		}
	}
}
public class VolumeCullingwLights : MonoBehaviour
{
	public GameObject[] RendererContainers;

	public GameObject[] LightContainers;

	public Vector3 VolumeCenter = Vector3.zero;

	public Vector3 VolumeSize = Vector3.one * 10f;

	private List<Renderer> _renderers = new List<Renderer>();

	private List<Light> _lights = new List<Light>();

	private bool _isVisible = true;

	public void Start()
	{
		int num = RendererContainers.Length;
		for (int i = 0; i < num; i++)
		{
			RendererContainers[i].GetComponentsInChildren<Renderer>(false, _renderers);
		}
		int num2 = RendererContainers.Length;
		for (int j = 0; j < num2; j++)
		{
			LightContainers[j].GetComponentsInChildren<Light>(false, _lights);
		}
	}

	public void LateUpdate()
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		ReadOnlyCollection<CameraRigController> readOnlyInstancesList = CameraRigController.readOnlyInstancesList;
		int count = readOnlyInstancesList.Count;
		bool flag = false;
		((Component)this).transform.TransformPoint(VolumeCenter);
		Bounds val = default(Bounds);
		((Bounds)(ref val))..ctor(VolumeCenter, VolumeSize);
		for (int i = 0; i < count; i++)
		{
			CameraRigController val2 = readOnlyInstancesList[i];
			Vector3 val3 = ((Component)this).transform.InverseTransformPoint(val2.currentCameraState.position);
			flag = ((Bounds)(ref val)).Contains(val3);
			if (flag)
			{
				break;
			}
		}
		if (_isVisible != flag)
		{
			_isVisible = flag;
			for (int j = 0; j < _renderers.Count; j++)
			{
				_renderers[j].enabled = _isVisible;
			}
			for (int k = 0; k < _lights.Count; k++)
			{
				((Behaviour)_lights[k]).enabled = _isVisible;
			}
		}
	}

	public void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.cyan;
		Matrix4x4 matrix = Gizmos.matrix;
		Gizmos.matrix = ((Component)this).transform.localToWorldMatrix;
		Gizmos.DrawWireCube(VolumeCenter, VolumeSize);
		Gizmos.matrix = matrix;
	}
}
namespace SnowtimeComponents
{
	[BepInPlugin("SnowySnowtime.SnowtimeComponents_Components", "SnowtimeComponents_Components", "1.0.1")]
	public class SnowtimeComponents : BaseUnityPlugin
	{
		public const string Author = "SnowySnowtime";

		public const string Name = "SnowtimeComponents_Components";

		public const string Version = "1.0.1";

		public const string GUID = "SnowySnowtime.SnowtimeComponents_Components";

		public static SnowtimeComponents instance;

		public void Awake()
		{
			instance = this;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HG.Reflection;
using Microsoft.CodeAnalysis;
using On.RoR2;
using R2API;
using RoR2;
using RoR2.ContentManagement;
using RoR2.ExpansionManagement;
using ShaderSwapper;
using Snowtime.Content;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SnowtimeStages")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f93a40505933251ade42c302b6e56c94395e6e5c")]
[assembly: AssemblyProduct("SnowtimeStages")]
[assembly: AssemblyTitle("SnowtimeStages")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Snowtime
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	[BepInPlugin("SnowySnowtime.SnowtimeStage", "SnowtimeStage", "0.9.9")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class SnowtimeStage : BaseUnityPlugin
	{
		public const string Author = "SnowySnowtime";

		public const string Name = "SnowtimeStage";

		public const string Version = "0.9.9";

		public const string GUID = "SnowySnowtime.SnowtimeStage";

		public static SnowtimeStage instance;

		public static ConfigEntry<bool> ToggleBloodGulch { get; set; }

		public static ConfigEntry<bool> ToggleSidewinder { get; set; }

		public static ConfigEntry<bool> ToggleDeathIsland { get; set; }

		public static ConfigEntry<bool> ToggleIceFields { get; set; }

		public static ConfigEntry<bool> ToggleGephyrophobia { get; set; }

		public static ConfigEntry<bool> ToggleSandtrap { get; set; }

		public static ConfigEntry<bool> ToggleHalo { get; set; }

		public static ConfigEntry<bool> ToggleHalo2 { get; set; }

		public static ConfigEntry<bool> ToggleNMB { get; set; }

		public static ConfigEntry<bool> ToggleGMC { get; set; }

		public static ConfigEntry<bool> ToggleDHalo { get; set; }

		public static ConfigEntry<bool> ToggleFLAT { get; set; }

		public static ConfigEntry<bool> ToggleHC { get; set; }

		public static ConfigEntry<bool> ToggleBig { get; set; }

		public static ConfigEntry<bool> ToggleHightower { get; set; }

		public static ConfigEntry<bool> ToggleMVM { get; set; }

		public static bool riskierLoaded => ModLoaded("com.RiskOfBrainrot.RiskierRain");

		public static bool ModLoaded(string modGuid)
		{
			return !string.IsNullOrEmpty(modGuid) && Chainloader.PluginInfos.ContainsKey(modGuid);
		}

		public void Awake()
		{
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Expected O, but got Unknown
			instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			ToggleBloodGulch = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 1 Toggles", "Blood Gulch", true, "If true, Blood Gulch is added to the loop, otherwise it shall not appear");
			ToggleSidewinder = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 1 Toggles", "Sidewinder", true, "If true, Sidewinder is added to the loop, otherwise it shall not appear");
			ToggleGMC = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 1 Toggles", "gm_construct", true, "If true, gm_construct is added to the loop, otherwise it shall not appear");
			ToggleDeathIsland = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 2 Toggles", "Death Island", true, "If true, Death Island is added to the loop, otherwise it shall not appear");
			ToggleIceFields = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 2 Toggles", "Ice Fields", true, "If true, Ice Fields is added to the loop, otherwise it shall not appear");
			ToggleDHalo = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 2 Toggles", "Delta Halo", false, "If true, Delta Halo is added to the loop, otherwise it shall not appear");
			ToggleGephyrophobia = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 3 Toggles", "Gephyrophobia", true, "If true, Gephyrophobia is added to the loop, otherwise it shall not appear");
			ToggleSandtrap = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 4 Toggles", "Sandtrap", true, "If true, Sandtrap is added to the loop, otherwise it shall not appear");
			ToggleHalo = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 5 Toggles", "Halo", true, "If true, Halo is added to the loop, otherwise it shall not appear");
			ToggleHalo2 = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 5 Toggles", "Halo(Alt)", true, "If true, Halo(Alt) is added to the loop, otherwise it shall not appear");
			ToggleNMB = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 3 Toggles", "New Mombasa Bridge", true, "If true, New Mombasa Bridge is added to the loop, otherwise it shall not appear");
			ToggleFLAT = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 5 Toggles", "gm_flatgrass", true, "If true, gm_flatgrass is added to the loop, otherwise it shall not appear");
			ToggleHC = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 4 Toggles", "High Charity", true, "If true, High Charity is added to the loop, otherwise it shall not appear");
			ToggleBig = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 4 (Bazaar Only) Toggles", "gm_bigcity", true, "If true, gm_bigcity is hidden in the bazaar, otherwise it shall not appear");
			ToggleHightower = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 2 Toggles", "plr_hightower", true, "If true, plr_hightower is added to the loop, otherwise it shall not appear");
			ToggleMVM = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage 3 Toggles", "mvm_mannhattan", true, "If true, mvm_mannhattan is added to the loop, otherwise it shall not appear");
			RegisterHooks();
			ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(GiveToRoR2OurContentPackProviders);
			Language.collectLanguageRootFolders += CollectLanguageRootFolders;
		}

		private void RegisterHooks()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			MusicController.StartIntroMusic += new hook_StartIntroMusic(MusicController_StartIntroMusic);
		}

		private void MusicController_StartIntroMusic(orig_StartIntroMusic orig, MusicController self)
		{
			orig.Invoke(self);
			AkSoundEngine.PostEvent("Play_Music_SystemST", ((Component)self).gameObject);
		}

		private void Destroy()
		{
			Language.collectLanguageRootFolders -= CollectLanguageRootFolders;
		}

		private void GiveToRoR2OurContentPackProviders(AddContentPackProviderDelegate addContentPackProvider)
		{
			addContentPackProvider.Invoke((IContentPackProvider)(object)new ContentProvider());
		}

		public void CollectLanguageRootFolders(List<string> folders)
		{
			folders.Add(Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Language"));
		}
	}
}
namespace Snowtime.Content
{
	public class ContentProvider : IContentPackProvider
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public AssetBundle scenesAssetBundle;

			public AssetBundle assetsAssetBundle;

			internal void <LoadStaticContentAsync>b__0(AssetBundle assetBundle)
			{
				scenesAssetBundle = assetBundle;
			}

			internal void <LoadStaticContentAsync>b__1(AssetBundle assetBundle)
			{
				assetsAssetBundle = assetBundle;
			}
		}

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

			private object <>2__current;

			public FinalizeAsyncArgs args;

			public ContentProvider <>4__this;

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

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

			[DebuggerHidden]
			public <FinalizeAsync>d__7(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;
				args.ReportProgress(1f);
				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 <GenerateContentPackAsync>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GetContentPackAsyncArgs args;

			public ContentProvider <>4__this;

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

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

			[DebuggerHidden]
			public <GenerateContentPackAsync>d__6(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;
				ContentPack.Copy(<>4__this._contentPack, args.output);
				args.ReportProgress(1f);
				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 <LoadAssetBundle>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string assetBundleFullPath;

			public IProgress<float> progress;

			public Action<AssetBundle> onAssetBundleLoaded;

			public ContentProvider <>4__this;

			private AssetBundleCreateRequest <assetBundleCreateRequest>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<assetBundleCreateRequest>5__1 = AssetBundle.LoadFromFileAsync(assetBundleFullPath);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!((AsyncOperation)<assetBundleCreateRequest>5__1).isDone)
				{
					progress.Report(((AsyncOperation)<assetBundleCreateRequest>5__1).progress);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				onAssetBundleLoaded(<assetBundleCreateRequest>5__1.assetBundle);
				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 <LoadStaticContentAsync>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LoadStaticContentAsyncArgs args;

			public ContentProvider <>4__this;

			private <>c__DisplayClass4_0 <>8__1;

			private string <assetsFolderFullPath>5__2;

			private string <musicFolderFullPath>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass4_0();
					<>4__this._contentPack.identifier = <>4__this.identifier;
					<assetsFolderFullPath>5__2 = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "assetbundles");
					assetDirectory = <assetsFolderFullPath>5__2;
					<musicFolderFullPath>5__3 = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "audio");
					SnowtimeContent.LoadSoundBanks(<musicFolderFullPath>5__3);
					<>8__1.scenesAssetBundle = null;
					<>2__current = <>4__this.LoadAssetBundle(Path.Combine(<assetsFolderFullPath>5__2, "snowtimestages"), args.progressReceiver, delegate(AssetBundle assetBundle)
					{
						<>8__1.scenesAssetBundle = assetBundle;
					});
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>8__1.assetsAssetBundle = null;
					<>2__current = <>4__this.LoadAssetBundle(Path.Combine(<assetsFolderFullPath>5__2, "snowtimeassets"), args.progressReceiver, delegate(AssetBundle assetBundle)
					{
						<>8__1.assetsAssetBundle = assetBundle;
					});
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAssetBundlesAsync(<>8__1.scenesAssetBundle, <>8__1.assetsAssetBundle, args.progressReceiver, <>4__this._contentPack);
					<>1__state = 3;
					return true;
				case 3:
					<>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();
			}
		}

		private readonly ContentPack _contentPack = new ContentPack();

		public static string assetDirectory;

		public string identifier => "SnowySnowtime.SnowtimeStage.ContentProvider";

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

		[IteratorStateMachine(typeof(<LoadAssetBundle>d__5))]
		private IEnumerator LoadAssetBundle(string assetBundleFullPath, IProgress<float> progress, Action<AssetBundle> onAssetBundleLoaded)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAssetBundle>d__5(0)
			{
				<>4__this = this,
				assetBundleFullPath = assetBundleFullPath,
				progress = progress,
				onAssetBundleLoaded = onAssetBundleLoaded
			};
		}

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

		[IteratorStateMachine(typeof(<FinalizeAsync>d__7))]
		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FinalizeAsync>d__7(0)
			{
				<>4__this = this,
				args = args
			};
		}
	}
	public static class SnowtimeContent
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass89_0
		{
			public ContentPack contentPack;

			internal void <LoadAssetBundlesAsync>b__0(UnlockableDef[] assets)
			{
				UnlockableDefs = assets;
				contentPack.unlockableDefs.Add(assets);
			}

			internal void <LoadAssetBundlesAsync>b__1(GameObject[] assets)
			{
				gameObjects = assets;
				CovenantCruiser = assets.First((GameObject a) => ((Object)a).name == "CovenantCruiserTeleporter");
				PurchaseLockCovenant = assets.First((GameObject a) => ((Object)a).name == "PurchaseLockCovenant");
				CovenantCruiserLunar = assets.First((GameObject a) => ((Object)a).name == "CovenantCruiserTeleporterLunar");
				LunarTeleporterProngsCustom = assets.First((GameObject a) => ((Object)a).name == "LunarTeleporterProngsCustom");
				PlatChest = assets.First((GameObject a) => ((Object)a).name == "PlatChest");
				GoldChest_Scaling = assets.First((GameObject a) => ((Object)a).name == "GoldChest_Scaling");
				stnwobjList.Add(CovenantCruiser);
				stnwobjList.Add(PurchaseLockCovenant);
				stnwobjList.Add(CovenantCruiserLunar);
				stnwobjList.Add(LunarTeleporterProngsCustom);
				stnwobjList.Add(PlatChest);
				stnwobjList.Add(GoldChest_Scaling);
				contentPack.networkedObjectPrefabs.Add(stnwobjList.ToArray());
				contentPack.bodyPrefabs.Add(stbodyList.ToArray());
				contentPack.masterPrefabs.Add(stmasterList.ToArray());
				contentPack.projectilePrefabs.Add(stprojectileList.ToArray());
				contentPack.effectDefs.Add(steffectList.ToArray());
			}

			internal void <LoadAssetBundlesAsync>b__2(ExpansionDef[] assets)
			{
				expansionDefs = assets;
				ExpansionDefSTHalo = assets.First((ExpansionDef a) => ((Object)a).name == "snowtimestageshalo_expdef");
				ExpansionDefSTSource = assets.First((ExpansionDef a) => ((Object)a).name == "snowtimestagessource_expdef");
				Log.Debug("SnowtimeStages:Halo Expansion Definition Added");
				Log.Debug("SnowtimeStages:Source Expansion Definition Added");
				contentPack.expansionDefs.Add(assets);
			}

			internal void <LoadAssetBundlesAsync>b__4(SceneDef[] assets)
			{
				SceneDefs = assets;
				Log.Debug("Adding enabled SceneDefs for SnowtimeStages");
				if (SnowtimeStage.ToggleBloodGulch.Value)
				{
					STBGSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_bloodgulch");
					stSceneDefList.Add(STBGSceneDef);
					Log.Debug("Added Blood Gulch SceneDef (Config On)");
					string text = ((object)(SceneType)(ref STBGSceneDef.sceneType)).ToString();
					Log.Debug("Blood Gulch's Scene Type = " + text);
					string text2 = STBGSceneDef.baseSceneName.ToString();
					Log.Debug("Blood Gulch's baseSceneName = " + text2);
				}
				if (!SnowtimeStage.ToggleBloodGulch.Value)
				{
					Log.Debug("Skipped Blood Gulch SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleSidewinder.Value)
				{
					STSWSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_sidewinder");
					stSceneDefList.Add(STSWSceneDef);
					Log.Debug("Added Sidewinder SceneDef (Config On)");
					string text3 = ((object)(SceneType)(ref STSWSceneDef.sceneType)).ToString();
					Log.Debug("Sidewinder's Scene Type = " + text3);
				}
				if (!SnowtimeStage.ToggleSidewinder.Value)
				{
					Log.Debug("Skipped Sidewinder SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleDeathIsland.Value)
				{
					STSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_deathisland");
					stSceneDefList.Add(STSceneDef);
					Log.Debug("Added Death Island SceneDef (Config On)");
					string text4 = ((object)(SceneType)(ref STSceneDef.sceneType)).ToString();
					Log.Debug("Death Island's Scene Type = " + text4);
				}
				if (!SnowtimeStage.ToggleDeathIsland.Value)
				{
					Log.Debug("Skipped Death Island SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleIceFields.Value)
				{
					STIFSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_icefields");
					stSceneDefList.Add(STIFSceneDef);
					Log.Debug("Added Ice Fields SceneDef (Config On)");
					string text5 = ((object)(SceneType)(ref STIFSceneDef.sceneType)).ToString();
					Log.Debug("Ice Fields' Scene Type = " + text5);
				}
				if (!SnowtimeStage.ToggleIceFields.Value)
				{
					Log.Debug("Skipped Ice Fields SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleGephyrophobia.Value)
				{
					STGPHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gephyrophobia");
					stSceneDefList.Add(STGPHSceneDef);
					Log.Debug("Added Gephyrophobia SceneDef (Config On)");
					string text6 = ((object)(SceneType)(ref STGPHSceneDef.sceneType)).ToString();
					Log.Debug("Gephyrophobia's Scene Type = " + text6);
				}
				if (!SnowtimeStage.ToggleGephyrophobia.Value)
				{
					Log.Debug("Skipped Gephyrophobia SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleSandtrap.Value)
				{
					STShrineSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_sandtrap");
					stSceneDefList.Add(STShrineSceneDef);
					Log.Debug("Added Sandtrap SceneDef (Config On)");
					string text7 = ((object)(SceneType)(ref STShrineSceneDef.sceneType)).ToString();
					Log.Debug("Sandtrap's Scene Type = " + text7);
				}
				if (!SnowtimeStage.ToggleSandtrap.Value)
				{
					Log.Debug("Skipped Sandtrap SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleHalo.Value)
				{
					STHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_halo");
					stSceneDefList.Add(STHSceneDef);
					Log.Debug("Added Halo SceneDef (Config On)");
					string text8 = ((object)(SceneType)(ref STHSceneDef.sceneType)).ToString();
					Log.Debug("Halo's Scene Type = " + text8);
				}
				if (!SnowtimeStage.ToggleHalo.Value)
				{
					Log.Debug("Skipped Halo SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleHalo2.Value)
				{
					STH2SceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_halo2");
					stSceneDefList.Add(STH2SceneDef);
					Log.Debug("Added Halo(Alt) SceneDef (Config On)");
					string text9 = ((object)(SceneType)(ref STH2SceneDef.sceneType)).ToString();
					Log.Debug("Halo(Alt)'s Scene Type = " + text9);
				}
				if (!SnowtimeStage.ToggleHalo2.Value)
				{
					Log.Debug("Skipped Halo(Alt) SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleNMB.Value)
				{
					STNMBSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_newmombasabridge");
					stSceneDefList.Add(STNMBSceneDef);
					Log.Debug("Added New Mombasa Bridge SceneDef (Config On)");
					string text10 = ((object)(SceneType)(ref STNMBSceneDef.sceneType)).ToString();
					Log.Debug("New Mombasa Bridge's Scene Type = " + text10);
				}
				if (!SnowtimeStage.ToggleNMB.Value)
				{
					Log.Debug("Skipped New Mombasa Bridge SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleGMC.Value)
				{
					STGMCSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmconstruct");
					stSceneDefList.Add(STGMCSceneDef);
					Log.Debug("Added gm_construct SceneDef (Config On)");
					string text11 = ((object)(SceneType)(ref STGMCSceneDef.sceneType)).ToString();
					Log.Debug("gm_construct's Scene Type = " + text11);
				}
				if (!SnowtimeStage.ToggleGMC.Value)
				{
					Log.Debug("Skipped gm_construct SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleDHalo.Value)
				{
					STDHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_deltahalo");
					stSceneDefList.Add(STDHSceneDef);
					Log.Debug("Added Delta Halo SceneDef (Config On)");
					string text12 = ((object)(SceneType)(ref STDHSceneDef.sceneType)).ToString();
					Log.Debug("Delta Halo's Scene Type = " + text12);
				}
				if (!SnowtimeStage.ToggleDHalo.Value)
				{
					Log.Debug("Skipped Delta Halo SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleFLAT.Value)
				{
					STFlatSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmflatgrass");
					stSceneDefList.Add(STFlatSceneDef);
					Log.Debug("Added gm_flatgrass SceneDef (Config On)");
					string text13 = ((object)(SceneType)(ref STFlatSceneDef.sceneType)).ToString();
					Log.Debug("gm_flatgrass's Scene Type = " + text13);
				}
				if (!SnowtimeStage.ToggleFLAT.Value)
				{
					Log.Debug("Skipped gm_flatgrass SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleHC.Value)
				{
					STHCSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_highcharity");
					stSceneDefList.Add(STHCSceneDef);
					Log.Debug("Added High Charity SceneDef (Config On)");
					string text14 = ((object)(SceneType)(ref STHCSceneDef.sceneType)).ToString();
					Log.Debug("High Charity's Scene Type = " + text14);
				}
				if (!SnowtimeStage.ToggleHC.Value)
				{
					Log.Debug("Skipped High Charity SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleBig.Value)
				{
					STCitySceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmbigcity");
					stSceneDefList.Add(STCitySceneDef);
					Log.Debug("Added gm_bigcity SceneDef (Config On)");
					string text15 = ((object)(SceneType)(ref STCitySceneDef.sceneType)).ToString();
					Log.Debug("gm_bigcity's Scene Type = " + text15);
				}
				if (!SnowtimeStage.ToggleBig.Value)
				{
					Log.Debug("Skipped gm_bigcity SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleHightower.Value)
				{
					STHightowerSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_plrhightower");
					stSceneDefList.Add(STHightowerSceneDef);
					Log.Debug("Added plr_hightower SceneDef (Config On)");
					string text16 = ((object)(SceneType)(ref STHightowerSceneDef.sceneType)).ToString();
					Log.Debug("plr_hightower's Scene Type = " + text16);
				}
				if (!SnowtimeStage.ToggleHightower.Value)
				{
					Log.Debug("Skipped plr_hightower SceneDef (Config Off)");
				}
				if (SnowtimeStage.ToggleMVM.Value)
				{
					STMVMSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_mvmmannhattan");
					stSceneDefList.Add(STMVMSceneDef);
					Log.Debug("Added mvm_mannhattan SceneDef (Config On)");
					string text17 = ((object)(SceneType)(ref STMVMSceneDef.sceneType)).ToString();
					Log.Debug("mvm_mannhattan's Scene Type = " + text17);
				}
				if (!SnowtimeStage.ToggleMVM.Value)
				{
					Log.Debug("Skipped mvm_mannhattan SceneDef (Config Off)");
				}
				contentPack.sceneDefs.Add(stSceneDefList.ToArray());
				Log.Debug("Finished adding enabled SceneDefs for SnowtimeStages");
			}

			internal void <LoadAssetBundlesAsync>b__5(MusicTrackDef[] assets)
			{
				contentPack.musicTrackDefs.Add(assets);
				Log.Debug("Loaded musicDefs for SnowtimeStages");
			}
		}

		[CompilerGenerated]
		private sealed class <LoadAllAssetsAsync>d__90<T> : IEnumerator<object>, IEnumerator, IDisposable where T : Object
		{
			private int <>1__state;

			private object <>2__current;

			public AssetBundle assetBundle;

			public IProgress<float> progress;

			public Action<T[]> onAssetsLoaded;

			private AssetBundleRequest <sceneDefsRequest>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sceneDefsRequest>5__1 = assetBundle.LoadAllAssetsAsync<T>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!((AsyncOperation)<sceneDefsRequest>5__1).isDone)
				{
					progress.Report(((AsyncOperation)<sceneDefsRequest>5__1).progress);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				onAssetsLoaded(<sceneDefsRequest>5__1.allAssets.Cast<T>().ToArray());
				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 <LoadAssetBundlesAsync>d__89 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AssetBundle scenesAssetBundle;

			public AssetBundle assetsAssetBundle;

			public IProgress<float> progress;

			public ContentPack contentPack;

			private <>c__DisplayClass89_0 <>8__1;

			private IEnumerator <upgradeStubbedShaders>5__2;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass89_0();
					<>8__1.contentPack = contentPack;
					_stscenesAssetBundle = scenesAssetBundle;
					_stassetsAssetBundle = assetsAssetBundle;
					Log.Debug("Snowtime Stages found. Loading asset bundles...");
					<upgradeStubbedShaders>5__2 = ShaderSwapper.UpgradeStubbedShadersAsync(_stassetsAssetBundle);
					goto IL_00d0;
				case 1:
					<>1__state = -1;
					goto IL_00d0;
				case 2:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<GameObject>(_stassetsAssetBundle, progress, (Action<GameObject[]>)delegate(GameObject[] assets)
					{
						gameObjects = assets;
						CovenantCruiser = assets.First((GameObject a) => ((Object)a).name == "CovenantCruiserTeleporter");
						PurchaseLockCovenant = assets.First((GameObject a) => ((Object)a).name == "PurchaseLockCovenant");
						CovenantCruiserLunar = assets.First((GameObject a) => ((Object)a).name == "CovenantCruiserTeleporterLunar");
						LunarTeleporterProngsCustom = assets.First((GameObject a) => ((Object)a).name == "LunarTeleporterProngsCustom");
						PlatChest = assets.First((GameObject a) => ((Object)a).name == "PlatChest");
						GoldChest_Scaling = assets.First((GameObject a) => ((Object)a).name == "GoldChest_Scaling");
						stnwobjList.Add(CovenantCruiser);
						stnwobjList.Add(PurchaseLockCovenant);
						stnwobjList.Add(CovenantCruiserLunar);
						stnwobjList.Add(LunarTeleporterProngsCustom);
						stnwobjList.Add(PlatChest);
						stnwobjList.Add(GoldChest_Scaling);
						<>8__1.contentPack.networkedObjectPrefabs.Add(stnwobjList.ToArray());
						<>8__1.contentPack.bodyPrefabs.Add(stbodyList.ToArray());
						<>8__1.contentPack.masterPrefabs.Add(stmasterList.ToArray());
						<>8__1.contentPack.projectilePrefabs.Add(stprojectileList.ToArray());
						<>8__1.contentPack.effectDefs.Add(steffectList.ToArray());
					});
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<ExpansionDef>(_stassetsAssetBundle, progress, (Action<ExpansionDef[]>)delegate(ExpansionDef[] assets)
					{
						expansionDefs = assets;
						ExpansionDefSTHalo = assets.First((ExpansionDef a) => ((Object)a).name == "snowtimestageshalo_expdef");
						ExpansionDefSTSource = assets.First((ExpansionDef a) => ((Object)a).name == "snowtimestagessource_expdef");
						Log.Debug("SnowtimeStages:Halo Expansion Definition Added");
						Log.Debug("SnowtimeStages:Source Expansion Definition Added");
						<>8__1.contentPack.expansionDefs.Add(assets);
					});
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<Sprite>(_stassetsAssetBundle, progress, (Action<Sprite[]>)delegate(Sprite[] assets)
					{
						STSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTScenePreview");
						STIFSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTIFScenePreview");
						STBGSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTBGScenePreview");
						STGPHSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTGPHScenePreview");
						STHSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTHaloScenePreview");
						STH2SceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTHaloScenePreview");
						STShrineSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTShrineScenePreview");
						STSWSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTSWScenePreview");
						STNMBSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTNMBScenePreview");
						STGMCSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTGMCScenePreview");
						STDHSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTDHaloScenePreview");
						STFlatSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTFlatScenePreview");
						STHCSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTHCScenePreview");
						STCitySceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTCityScenePreview");
						STHightowerSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTHightowerScenePreview");
						STMVMSceneDefPreviewSprite = assets.First((Sprite a) => ((Object)a).name == "texSTMVMScenePreview");
					});
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<SceneDef>(_stassetsAssetBundle, progress, (Action<SceneDef[]>)delegate(SceneDef[] assets)
					{
						SceneDefs = assets;
						Log.Debug("Adding enabled SceneDefs for SnowtimeStages");
						if (SnowtimeStage.ToggleBloodGulch.Value)
						{
							STBGSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_bloodgulch");
							stSceneDefList.Add(STBGSceneDef);
							Log.Debug("Added Blood Gulch SceneDef (Config On)");
							string text = ((object)(SceneType)(ref STBGSceneDef.sceneType)).ToString();
							Log.Debug("Blood Gulch's Scene Type = " + text);
							string text2 = STBGSceneDef.baseSceneName.ToString();
							Log.Debug("Blood Gulch's baseSceneName = " + text2);
						}
						if (!SnowtimeStage.ToggleBloodGulch.Value)
						{
							Log.Debug("Skipped Blood Gulch SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleSidewinder.Value)
						{
							STSWSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_sidewinder");
							stSceneDefList.Add(STSWSceneDef);
							Log.Debug("Added Sidewinder SceneDef (Config On)");
							string text3 = ((object)(SceneType)(ref STSWSceneDef.sceneType)).ToString();
							Log.Debug("Sidewinder's Scene Type = " + text3);
						}
						if (!SnowtimeStage.ToggleSidewinder.Value)
						{
							Log.Debug("Skipped Sidewinder SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleDeathIsland.Value)
						{
							STSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_deathisland");
							stSceneDefList.Add(STSceneDef);
							Log.Debug("Added Death Island SceneDef (Config On)");
							string text4 = ((object)(SceneType)(ref STSceneDef.sceneType)).ToString();
							Log.Debug("Death Island's Scene Type = " + text4);
						}
						if (!SnowtimeStage.ToggleDeathIsland.Value)
						{
							Log.Debug("Skipped Death Island SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleIceFields.Value)
						{
							STIFSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_icefields");
							stSceneDefList.Add(STIFSceneDef);
							Log.Debug("Added Ice Fields SceneDef (Config On)");
							string text5 = ((object)(SceneType)(ref STIFSceneDef.sceneType)).ToString();
							Log.Debug("Ice Fields' Scene Type = " + text5);
						}
						if (!SnowtimeStage.ToggleIceFields.Value)
						{
							Log.Debug("Skipped Ice Fields SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleGephyrophobia.Value)
						{
							STGPHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gephyrophobia");
							stSceneDefList.Add(STGPHSceneDef);
							Log.Debug("Added Gephyrophobia SceneDef (Config On)");
							string text6 = ((object)(SceneType)(ref STGPHSceneDef.sceneType)).ToString();
							Log.Debug("Gephyrophobia's Scene Type = " + text6);
						}
						if (!SnowtimeStage.ToggleGephyrophobia.Value)
						{
							Log.Debug("Skipped Gephyrophobia SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleSandtrap.Value)
						{
							STShrineSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_sandtrap");
							stSceneDefList.Add(STShrineSceneDef);
							Log.Debug("Added Sandtrap SceneDef (Config On)");
							string text7 = ((object)(SceneType)(ref STShrineSceneDef.sceneType)).ToString();
							Log.Debug("Sandtrap's Scene Type = " + text7);
						}
						if (!SnowtimeStage.ToggleSandtrap.Value)
						{
							Log.Debug("Skipped Sandtrap SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleHalo.Value)
						{
							STHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_halo");
							stSceneDefList.Add(STHSceneDef);
							Log.Debug("Added Halo SceneDef (Config On)");
							string text8 = ((object)(SceneType)(ref STHSceneDef.sceneType)).ToString();
							Log.Debug("Halo's Scene Type = " + text8);
						}
						if (!SnowtimeStage.ToggleHalo.Value)
						{
							Log.Debug("Skipped Halo SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleHalo2.Value)
						{
							STH2SceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_halo2");
							stSceneDefList.Add(STH2SceneDef);
							Log.Debug("Added Halo(Alt) SceneDef (Config On)");
							string text9 = ((object)(SceneType)(ref STH2SceneDef.sceneType)).ToString();
							Log.Debug("Halo(Alt)'s Scene Type = " + text9);
						}
						if (!SnowtimeStage.ToggleHalo2.Value)
						{
							Log.Debug("Skipped Halo(Alt) SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleNMB.Value)
						{
							STNMBSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_newmombasabridge");
							stSceneDefList.Add(STNMBSceneDef);
							Log.Debug("Added New Mombasa Bridge SceneDef (Config On)");
							string text10 = ((object)(SceneType)(ref STNMBSceneDef.sceneType)).ToString();
							Log.Debug("New Mombasa Bridge's Scene Type = " + text10);
						}
						if (!SnowtimeStage.ToggleNMB.Value)
						{
							Log.Debug("Skipped New Mombasa Bridge SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleGMC.Value)
						{
							STGMCSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmconstruct");
							stSceneDefList.Add(STGMCSceneDef);
							Log.Debug("Added gm_construct SceneDef (Config On)");
							string text11 = ((object)(SceneType)(ref STGMCSceneDef.sceneType)).ToString();
							Log.Debug("gm_construct's Scene Type = " + text11);
						}
						if (!SnowtimeStage.ToggleGMC.Value)
						{
							Log.Debug("Skipped gm_construct SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleDHalo.Value)
						{
							STDHSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_deltahalo");
							stSceneDefList.Add(STDHSceneDef);
							Log.Debug("Added Delta Halo SceneDef (Config On)");
							string text12 = ((object)(SceneType)(ref STDHSceneDef.sceneType)).ToString();
							Log.Debug("Delta Halo's Scene Type = " + text12);
						}
						if (!SnowtimeStage.ToggleDHalo.Value)
						{
							Log.Debug("Skipped Delta Halo SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleFLAT.Value)
						{
							STFlatSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmflatgrass");
							stSceneDefList.Add(STFlatSceneDef);
							Log.Debug("Added gm_flatgrass SceneDef (Config On)");
							string text13 = ((object)(SceneType)(ref STFlatSceneDef.sceneType)).ToString();
							Log.Debug("gm_flatgrass's Scene Type = " + text13);
						}
						if (!SnowtimeStage.ToggleFLAT.Value)
						{
							Log.Debug("Skipped gm_flatgrass SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleHC.Value)
						{
							STHCSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_highcharity");
							stSceneDefList.Add(STHCSceneDef);
							Log.Debug("Added High Charity SceneDef (Config On)");
							string text14 = ((object)(SceneType)(ref STHCSceneDef.sceneType)).ToString();
							Log.Debug("High Charity's Scene Type = " + text14);
						}
						if (!SnowtimeStage.ToggleHC.Value)
						{
							Log.Debug("Skipped High Charity SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleBig.Value)
						{
							STCitySceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_gmbigcity");
							stSceneDefList.Add(STCitySceneDef);
							Log.Debug("Added gm_bigcity SceneDef (Config On)");
							string text15 = ((object)(SceneType)(ref STCitySceneDef.sceneType)).ToString();
							Log.Debug("gm_bigcity's Scene Type = " + text15);
						}
						if (!SnowtimeStage.ToggleBig.Value)
						{
							Log.Debug("Skipped gm_bigcity SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleHightower.Value)
						{
							STHightowerSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_plrhightower");
							stSceneDefList.Add(STHightowerSceneDef);
							Log.Debug("Added plr_hightower SceneDef (Config On)");
							string text16 = ((object)(SceneType)(ref STHightowerSceneDef.sceneType)).ToString();
							Log.Debug("plr_hightower's Scene Type = " + text16);
						}
						if (!SnowtimeStage.ToggleHightower.Value)
						{
							Log.Debug("Skipped plr_hightower SceneDef (Config Off)");
						}
						if (SnowtimeStage.ToggleMVM.Value)
						{
							STMVMSceneDef = assets.First((SceneDef sd) => sd.cachedName == "snowtime_mvmmannhattan");
							stSceneDefList.Add(STMVMSceneDef);
							Log.Debug("Added mvm_mannhattan SceneDef (Config On)");
							string text17 = ((object)(SceneType)(ref STMVMSceneDef.sceneType)).ToString();
							Log.Debug("mvm_mannhattan's Scene Type = " + text17);
						}
						if (!SnowtimeStage.ToggleMVM.Value)
						{
							Log.Debug("Skipped mvm_mannhattan SceneDef (Config Off)");
						}
						<>8__1.contentPack.sceneDefs.Add(stSceneDefList.ToArray());
						Log.Debug("Finished adding enabled SceneDefs for SnowtimeStages");
					});
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<MusicTrackDef>(_stassetsAssetBundle, progress, (Action<MusicTrackDef[]>)delegate(MusicTrackDef[] assets)
					{
						<>8__1.contentPack.musicTrackDefs.Add(assets);
						Log.Debug("Loaded musicDefs for SnowtimeStages");
					});
					<>1__state = 7;
					return true;
				case 7:
					{
						<>1__state = -1;
						Log.Debug("Adding Stages to the Loop + Bazaar Seer Materials");
						Log.Debug("Blood Gulch Config Status?");
						Log.Debug(SnowtimeStage.ToggleBloodGulch.Value);
						if (SnowtimeStage.ToggleBloodGulch.Value)
						{
							STBGBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STBGSceneDefPreviewSprite.texture);
							STBGSceneDef.previewTexture = (Texture)(object)STBGSceneDefPreviewSprite.texture;
							STBGSceneDef.portalMaterial = STBGBazaarSeer;
							Log.Debug("Blood Gulch Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STBGSceneDef, 1f, true, true);
							Log.Debug("Added Blood Gulch to loop");
							Log.Debug(STBGSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleBloodGulch.Value)
						{
							Log.Debug("Skipped adding Blood Gulch to the loop");
						}
						Log.Debug("Sidewinder Config Status?");
						Log.Debug(SnowtimeStage.ToggleSidewinder.Value);
						if (SnowtimeStage.ToggleSidewinder.Value)
						{
							STSWBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STSWSceneDefPreviewSprite.texture);
							STSWSceneDef.previewTexture = (Texture)(object)STSWSceneDefPreviewSprite.texture;
							STSWSceneDef.portalMaterial = STSWBazaarSeer;
							Log.Debug("Sidewinder Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STSWSceneDef, 1f, true, true);
							Log.Debug("Added Sidewinder to the loop");
							Log.Debug(STSWSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleSidewinder.Value)
						{
							Log.Debug("Skipped adding Sidewinder to the loop");
						}
						Log.Debug("Death Island Config Status?");
						Log.Debug(SnowtimeStage.ToggleDeathIsland.Value);
						if (SnowtimeStage.ToggleDeathIsland.Value)
						{
							STBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STSceneDefPreviewSprite.texture);
							STSceneDef.previewTexture = (Texture)(object)STSceneDefPreviewSprite.texture;
							STSceneDef.portalMaterial = STBazaarSeer;
							Log.Debug("Death Island Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STSceneDef, 1f, true, true);
							Log.Debug("Added Death Island to the loop");
							Log.Debug(STSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleDeathIsland.Value)
						{
							Log.Debug("Skipped adding Death Island to the loop");
						}
						Log.Debug("Ice Fields Config Status?");
						Log.Debug(SnowtimeStage.ToggleIceFields.Value);
						if (SnowtimeStage.ToggleIceFields.Value)
						{
							STIFBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STIFSceneDefPreviewSprite.texture);
							STIFSceneDef.previewTexture = (Texture)(object)STIFSceneDefPreviewSprite.texture;
							STIFSceneDef.portalMaterial = STIFBazaarSeer;
							Log.Debug("Ice Fields Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STIFSceneDef, 1f, true, true);
							Log.Debug("Added Ice Fields to the loop");
							Log.Debug(STIFSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleIceFields.Value)
						{
							Log.Debug("Skipped adding Ice Fields to the loop");
						}
						Log.Debug("Gephyrophobia Config Status?");
						Log.Debug(SnowtimeStage.ToggleGephyrophobia.Value);
						if (SnowtimeStage.ToggleGephyrophobia.Value)
						{
							STGPHBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STGPHSceneDefPreviewSprite.texture);
							STGPHSceneDef.previewTexture = (Texture)(object)STGPHSceneDefPreviewSprite.texture;
							STGPHSceneDef.portalMaterial = STGPHBazaarSeer;
							Log.Debug("Gephyrophobia Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STGPHSceneDef, 1f, true, true);
							Log.Debug("Added Gephyrophobia to the loop");
							Log.Debug(STGPHSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleGephyrophobia.Value)
						{
							Log.Debug("Skipped adding Gephyrophobia to the loop");
						}
						Log.Debug("Sandtrap Config Status?");
						Log.Debug(SnowtimeStage.ToggleSandtrap.Value);
						if (SnowtimeStage.ToggleSandtrap.Value)
						{
							STShrineBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STShrineSceneDefPreviewSprite.texture);
							STShrineSceneDef.previewTexture = (Texture)(object)STShrineSceneDefPreviewSprite.texture;
							STShrineSceneDef.portalMaterial = STShrineBazaarSeer;
							Log.Debug("Sandtrap Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STShrineSceneDef, 1f, true, true);
							Log.Debug("Added Sandtrap to the loop");
							Log.Debug(STShrineSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleSandtrap.Value)
						{
							Log.Debug("Skipped adding Sandtrap to the loop");
						}
						Log.Debug("Halo Config Status?");
						Log.Debug(SnowtimeStage.ToggleHalo.Value);
						if (SnowtimeStage.ToggleHalo.Value)
						{
							STHBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STHSceneDefPreviewSprite.texture);
							STHSceneDef.previewTexture = (Texture)(object)STHSceneDefPreviewSprite.texture;
							STHSceneDef.portalMaterial = STHBazaarSeer;
							Log.Debug("Halo Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STHSceneDef, 1f, true, true);
							Log.Debug("Added Halo to the loop");
							Log.Debug(STHSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleHalo.Value)
						{
							Log.Debug("Skipped adding Halo to the loop");
						}
						Log.Debug("Halo Config Status?");
						Log.Debug(SnowtimeStage.ToggleHalo2.Value);
						if (SnowtimeStage.ToggleHalo2.Value)
						{
							STH2BazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STH2SceneDefPreviewSprite.texture);
							STH2SceneDef.previewTexture = (Texture)(object)STH2SceneDefPreviewSprite.texture;
							STH2SceneDef.portalMaterial = STH2BazaarSeer;
							Log.Debug("Halo(Alt) Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STH2SceneDef, 1f, true, true);
							Log.Debug("Added Halo(Alt) to the loop");
							Log.Debug(STH2SceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleHalo2.Value)
						{
							Log.Debug("Skipped adding Halo(Alt) to the loop");
						}
						Log.Debug("New Mombasa Bridge Config Status?");
						Log.Debug(SnowtimeStage.ToggleNMB.Value);
						if (SnowtimeStage.ToggleNMB.Value)
						{
							STNMBBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STNMBSceneDefPreviewSprite.texture);
							STNMBSceneDef.previewTexture = (Texture)(object)STNMBSceneDefPreviewSprite.texture;
							STNMBSceneDef.portalMaterial = STNMBBazaarSeer;
							Log.Debug("New Mombasa Bridge Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STNMBSceneDef, 1f, true, true);
							Log.Debug("Added New Mombasa Bridge to the loop");
							Log.Debug(STNMBSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleNMB.Value)
						{
							Log.Debug("Skipped adding New Mombasa Bridge to the loop");
						}
						Log.Debug("gm_construct Config Status?");
						Log.Debug(SnowtimeStage.ToggleGMC.Value);
						if (SnowtimeStage.ToggleGMC.Value)
						{
							STGMCBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STGMCSceneDefPreviewSprite.texture);
							STGMCSceneDef.previewTexture = (Texture)(object)STGMCSceneDefPreviewSprite.texture;
							STGMCSceneDef.portalMaterial = STGMCBazaarSeer;
							Log.Debug("gm_construct Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STGMCSceneDef, 1f, true, true);
							Log.Debug("Added gm_construct to the loop");
							Log.Debug(STGMCSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleGMC.Value)
						{
							Log.Debug("Skipped adding gm_construct to the loop");
						}
						Log.Debug("Delta Halo Config Status?");
						Log.Debug(SnowtimeStage.ToggleDHalo.Value);
						if (SnowtimeStage.ToggleDHalo.Value)
						{
							STDHBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STDHSceneDefPreviewSprite.texture);
							STDHSceneDef.previewTexture = (Texture)(object)STDHSceneDefPreviewSprite.texture;
							STDHSceneDef.portalMaterial = STDHBazaarSeer;
							Log.Debug("Delta Halo Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STDHSceneDef, 1f, true, true);
							Log.Debug("Added Delta Halo to the loop");
							Log.Debug(STDHSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleDHalo.Value)
						{
							Log.Debug("Skipped adding Delta Halo to the loop");
						}
						Log.Debug("gm_flatgrass Config Status?");
						Log.Debug(SnowtimeStage.ToggleFLAT.Value);
						if (SnowtimeStage.ToggleFLAT.Value)
						{
							STFlatBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STFlatSceneDefPreviewSprite.texture);
							STFlatSceneDef.previewTexture = (Texture)(object)STFlatSceneDefPreviewSprite.texture;
							STFlatSceneDef.portalMaterial = STFlatBazaarSeer;
							Log.Debug("gm_flatgrass Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STFlatSceneDef, 1f, true, true);
							Log.Debug("Added gm_flatgrass to the loop");
							Log.Debug(STFlatSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleFLAT.Value)
						{
							Log.Debug("Skipped adding gm_flatgrass to the loop");
						}
						Log.Debug("High Charity Config Status?");
						Log.Debug(SnowtimeStage.ToggleHC.Value);
						if (SnowtimeStage.ToggleHC.Value)
						{
							STHCBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STHCSceneDefPreviewSprite.texture);
							STHCSceneDef.previewTexture = (Texture)(object)STHCSceneDefPreviewSprite.texture;
							STHCSceneDef.portalMaterial = STHCBazaarSeer;
							Log.Debug("High Charity Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STHCSceneDef, 1f, true, true);
							Log.Debug("Added High Charity to the loop");
							Log.Debug(STHCSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleHC.Value)
						{
							Log.Debug("Skipped adding High Charity to the loop");
						}
						if (SnowtimeStage.ToggleBig.Value)
						{
							STCityBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STCitySceneDefPreviewSprite.texture);
							STCitySceneDef.previewTexture = (Texture)(object)STCitySceneDefPreviewSprite.texture;
							STCitySceneDef.portalMaterial = STCityBazaarSeer;
							Log.Debug("gm_bigcity Bazaar Seer Material Complete");
							Log.Debug("Hid gm_bigcity on stage 4's Bazaar");
						}
						if (!SnowtimeStage.ToggleBig.Value)
						{
							Log.Debug("Skipped hiding gm_bigcity in the bazaar");
						}
						Log.Debug("plr_hightower Config Status?");
						Log.Debug(SnowtimeStage.ToggleHightower.Value);
						if (SnowtimeStage.ToggleHightower.Value)
						{
							STHightowerBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STHightowerSceneDefPreviewSprite.texture);
							STHightowerSceneDef.previewTexture = (Texture)(object)STHightowerSceneDefPreviewSprite.texture;
							STHightowerSceneDef.portalMaterial = STHightowerBazaarSeer;
							Log.Debug("plr_hightower Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STHightowerSceneDef, 1f, true, true);
							Log.Debug("Added plr_hightower to the loop");
							Log.Debug(STHightowerSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleHightower.Value)
						{
							Log.Debug("Skipped adding plr_hightower to the loop");
						}
						Log.Debug("mvm_mannhattan Config Status?");
						Log.Debug(SnowtimeStage.ToggleMVM.Value);
						if (SnowtimeStage.ToggleMVM.Value)
						{
							STMVMBazaarSeer = StageRegistration.MakeBazaarSeerMaterial(STMVMSceneDefPreviewSprite.texture);
							STMVMSceneDef.previewTexture = (Texture)(object)STMVMSceneDefPreviewSprite.texture;
							STMVMSceneDef.portalMaterial = STMVMBazaarSeer;
							Log.Debug("mvm_mannhattan Bazaar Seer Material Complete");
							StageRegistration.RegisterSceneDefToNormalProgression(STMVMSceneDef, 1f, true, true);
							Log.Debug("Added mvm_mannhattan to the loop");
							Log.Debug(STMVMSceneDef.destinationsGroup);
						}
						if (!SnowtimeStage.ToggleMVM.Value)
						{
							Log.Debug("Skipped adding mvm_mannhattan to the loop");
						}
						return false;
					}
					IL_00d0:
					if (<upgradeStubbedShaders>5__2.MoveNext())
					{
						<>2__current = <upgradeStubbedShaders>5__2.Current;
						<>1__state = 1;
						return true;
					}
					<>2__current = SnowtimeContent.LoadAllAssetsAsync<UnlockableDef>(_stassetsAssetBundle, progress, (Action<UnlockableDef[]>)delegate(UnlockableDef[] assets)
					{
						UnlockableDefs = assets;
						<>8__1.contentPack.unlockableDefs.Add(assets);
					});
					<>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();
			}
		}

		internal const string ScenesAssetBundleFileName = "snowtimestages";

		internal const string AssetsAssetBundleFileName = "snowtimeassets";

		internal const string MusicSoundBankFileName = "SnowtimeStagesMusic.bnk";

		internal const string SndSoundBankFileName = "SnowtimeStagesSounds.bnk";

		internal const string InitSoundBankFileName = "SnowtimeStagesInit.bnk";

		public static AssetBundle _stscenesAssetBundle;

		public static AssetBundle _stassetsAssetBundle;

		internal static UnlockableDef[] UnlockableDefs;

		internal static SceneDef[] SceneDefs;

		internal static ExpansionDef[] expansionDefs;

		internal static GameObject[] gameObjects;

		internal static EntityStateConfiguration[] EntityStateConfigurations;

		public static List<EntityStateConfiguration> stentStateConfig = new List<EntityStateConfiguration>();

		public static List<SceneDef> stSceneDefList = new List<SceneDef>();

		public static List<Material> SwappedMaterials = new List<Material>();

		public static List<GameObject> stbodyList = new List<GameObject>();

		public static List<GameObject> stmasterList = new List<GameObject>();

		public static List<GameObject> stprojectileList = new List<GameObject>();

		public static List<GameObject> stnwobjList = new List<GameObject>();

		public static List<GameObject> stghostList = new List<GameObject>();

		public static List<EffectDef> steffectList = new List<EffectDef>();

		public static List<EliteDef> steliteList = new List<EliteDef>();

		public static List<EquipmentDef> stequipList = new List<EquipmentDef>();

		public static List<BuffDef> stbuffList = new List<BuffDef>();

		internal static ExpansionDef ExpansionDefSTHalo;

		internal static ExpansionDef ExpansionDefSTSource;

		internal static SceneDef STSceneDef;

		internal static Sprite STSceneDefPreviewSprite;

		internal static Material STBazaarSeer;

		internal static SceneDef STIFSceneDef;

		internal static Sprite STIFSceneDefPreviewSprite;

		internal static Material STIFBazaarSeer;

		internal static SceneDef STBGSceneDef;

		internal static Sprite STBGSceneDefPreviewSprite;

		internal static Material STBGBazaarSeer;

		internal static SceneDef STGPHSceneDef;

		internal static Sprite STGPHSceneDefPreviewSprite;

		internal static Material STGPHBazaarSeer;

		internal static SceneDef STHSceneDef;

		internal static Sprite STHSceneDefPreviewSprite;

		internal static Material STHBazaarSeer;

		internal static SceneDef STH2SceneDef;

		internal static Sprite STH2SceneDefPreviewSprite;

		internal static Material STH2BazaarSeer;

		internal static SceneDef STShrineSceneDef;

		internal static Sprite STShrineSceneDefPreviewSprite;

		internal static Material STShrineBazaarSeer;

		internal static SceneDef STSWSceneDef;

		internal static Sprite STSWSceneDefPreviewSprite;

		internal static Material STSWBazaarSeer;

		internal static SceneDef STNMBSceneDef;

		internal static Sprite STNMBSceneDefPreviewSprite;

		internal static Material STNMBBazaarSeer;

		internal static SceneDef STGMCSceneDef;

		internal static Sprite STGMCSceneDefPreviewSprite;

		internal static Material STGMCBazaarSeer;

		internal static SceneDef STDHSceneDef;

		internal static Sprite STDHSceneDefPreviewSprite;

		internal static Material STDHBazaarSeer;

		internal static SceneDef STFlatSceneDef;

		internal static Sprite STFlatSceneDefPreviewSprite;

		internal static Material STFlatBazaarSeer;

		internal static SceneDef STHCSceneDef;

		internal static Sprite STHCSceneDefPreviewSprite;

		internal static Material STHCBazaarSeer;

		internal static SceneDef STCitySceneDef;

		internal static Sprite STCitySceneDefPreviewSprite;

		internal static Material STCityBazaarSeer;

		internal static SceneDef STMVMSceneDef;

		internal static Sprite STMVMSceneDefPreviewSprite;

		internal static Material STMVMBazaarSeer;

		internal static SceneDef STHightowerSceneDef;

		internal static Sprite STHightowerSceneDefPreviewSprite;

		internal static Material STHightowerBazaarSeer;

		internal static GameObject CovenantCruiser;

		internal static GameObject CovenantCruiserLunar;

		internal static GameObject LunarTeleporterProngsCustom;

		internal static GameObject PurchaseLockCovenant;

		internal static GameObject PlatChest;

		internal static GameObject GoldChest_Scaling;

		internal static GameObject LemurianErrorBody;

		internal static GameObject LemurianErrorMaster;

		internal static GameObject MissingBall;

		internal static GameObject MissingHit;

		internal static GameObject MissingFlash;

		internal static GameObject MissingExplFX;

		internal static GameObject MissingGhost;

		internal static InteractableSpawnCard PlatinumChestCard;

		internal static EntityStateConfiguration LemurianErrorEsc;

		[IteratorStateMachine(typeof(<LoadAssetBundlesAsync>d__89))]
		internal static IEnumerator LoadAssetBundlesAsync(AssetBundle scenesAssetBundle, AssetBundle assetsAssetBundle, IProgress<float> progress, ContentPack contentPack)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAssetBundlesAsync>d__89(0)
			{
				scenesAssetBundle = scenesAssetBundle,
				assetsAssetBundle = assetsAssetBundle,
				progress = progress,
				contentPack = contentPack
			};
		}

		[IteratorStateMachine(typeof(<LoadAllAssetsAsync>d__90<>))]
		private static IEnumerator LoadAllAssetsAsync<T>(AssetBundle assetBundle, IProgress<float> progress, Action<T[]> onAssetsLoaded) where T : Object
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAllAssetsAsync>d__90<T>(0)
			{
				assetBundle = assetBundle,
				progress = progress,
				onAssetsLoaded = onAssetsLoaded
			};
		}

		internal static void LoadSoundBanks(string soundbanksFolderPath)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			AKRESULT val = AkSoundEngine.AddBasePath(soundbanksFolderPath);
			if ((int)val == 1)
			{
				Log.Info("Added bank base path : " + soundbanksFolderPath);
			}
			else
			{
				Log.Error("Error adding base path : " + soundbanksFolderPath + " " + $"Error code : {val}");
			}
			uint num = default(uint);
			val = AkSoundEngine.LoadBank("SnowtimeStagesInit.bnk", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : SnowtimeStagesInit.bnk");
			}
			else
			{
				Log.Error("Error loading bank : SnowtimeStagesInit.bnk " + $"Error code : {val}");
			}
			val = AkSoundEngine.LoadBank("SnowtimeStagesMusic.bnk", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : SnowtimeStagesMusic.bnk");
			}
			else
			{
				Log.Error("Error loading bank : SnowtimeStagesMusic.bnk " + $"Error code : {val}");
			}
			val = AkSoundEngine.LoadBank("SnowtimeStagesSounds.bnk", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : SnowtimeStagesSounds.bnk");
			}
			else
			{
				Log.Error("Error loading bank : SnowtimeStagesSounds.bnk " + $"Error code : {val}");
			}
		}
	}
}