using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("dev.thatdrw.mvp.froggedupmenu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("dev.thatdrw.mvp.froggedupmenu")]
[assembly: AssemblyTitle("FroggedUpMenu")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace FrogSpawner
{
	[BepInPlugin("dev.thatdrw.mvp.froggedupmenu", "MVP_FroggedUpMenu", "1.0.0")]
	public class FrogSpawnerPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <FlyAlongPath>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject frog;

			public Vector3[] path;

			public bool reverse;

			public FrogSpawnerPlugin <>4__this;

			private Vector3[] <waypoints>5__1;

			private int <i>5__2;

			private int <seg>5__3;

			private Vector3 <p0>5__4;

			private Vector3 <p1>5__5;

			private Vector3 <p2>5__6;

			private Vector3 <p3>5__7;

			private float <segLength>5__8;

			private float <segDuration>5__9;

			private float <elapsed>5__10;

			private float <t>5__11;

			private Vector3 <pos>5__12;

			private Vector3 <nextPos>5__13;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: 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_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_023f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				//IL_024f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0254: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0277;
				}
				<>1__state = -1;
				if (reverse)
				{
					<waypoints>5__1 = (Vector3[])(object)new Vector3[path.Length];
					<i>5__2 = 0;
					while (<i>5__2 < path.Length)
					{
						<waypoints>5__1[<i>5__2] = path[path.Length - 1 - <i>5__2];
						<i>5__2++;
					}
				}
				else
				{
					<waypoints>5__1 = path;
				}
				<seg>5__3 = 0;
				goto IL_029f;
				IL_029f:
				if (<seg>5__3 < <waypoints>5__1.Length - 1)
				{
					<p0>5__4 = <waypoints>5__1[Mathf.Max(<seg>5__3 - 1, 0)];
					<p1>5__5 = <waypoints>5__1[<seg>5__3];
					<p2>5__6 = <waypoints>5__1[<seg>5__3 + 1];
					<p3>5__7 = <waypoints>5__1[Mathf.Min(<seg>5__3 + 2, <waypoints>5__1.Length - 1)];
					<segLength>5__8 = Vector3.Distance(<p1>5__5, <p2>5__6);
					<segDuration>5__9 = <segLength>5__8 / 4f;
					<elapsed>5__10 = 0f;
					goto IL_0277;
				}
				if ((Object)(object)frog != (Object)null)
				{
					Object.Destroy((Object)(object)frog);
				}
				return false;
				IL_0277:
				if (<elapsed>5__10 < <segDuration>5__9)
				{
					if ((Object)(object)frog == (Object)null)
					{
						return false;
					}
					<elapsed>5__10 += Time.deltaTime;
					<t>5__11 = Mathf.Clamp01(<elapsed>5__10 / <segDuration>5__9);
					<pos>5__12 = CatmullRom(<p0>5__4, <p1>5__5, <p2>5__6, <p3>5__7, <t>5__11);
					<nextPos>5__13 = CatmullRom(<p0>5__4, <p1>5__5, <p2>5__6, <p3>5__7, Mathf.Clamp01(<t>5__11 + 0.01f));
					frog.transform.position = <pos>5__12;
					if (<nextPos>5__13 != <pos>5__12)
					{
						frog.transform.rotation = Quaternion.LookRotation(<nextPos>5__13 - <pos>5__12, Vector3.up);
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<seg>5__3++;
				goto IL_029f;
			}

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

			private object <>2__current;

			public Vector3[] path;

			public int pathIndex;

			public FrogSpawnerPlugin <>4__this;

			private int <frogSeq>5__1;

			private float <delay>5__2;

			private bool <reverse>5__3;

			private Vector3 <startPoint>5__4;

			private GameObject <frog>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<frogSeq>5__1 = 0;
					break;
				case 1:
					<>1__state = -1;
					if ((Object)(object)<>4__this._npcFrogPrefab == (Object)null)
					{
						return false;
					}
					<reverse>5__3 = Random.value > 0.5f;
					<startPoint>5__4 = (<reverse>5__3 ? path[path.Length - 1] : path[0]);
					<frog>5__5 = Object.Instantiate<GameObject>(<>4__this._npcFrogPrefab, <startPoint>5__4, Quaternion.identity);
					((Object)<frog>5__5).name = $"NpcFrog_Flying_P{pathIndex}_{<frogSeq>5__1++}";
					<frog>5__5.SetActive(true);
					<>4__this.AddSmokeTrail(<frog>5__5);
					<>4__this.AddFrogAudio(<frog>5__5);
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.FlyAlongPath(<frog>5__5, path, <reverse>5__3));
					<frog>5__5 = null;
					break;
				}
				<delay>5__2 = Random.Range(2f, 16f);
				<>2__current = (object)new WaitForSeconds(<delay>5__2);
				<>1__state = 1;
				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 <SpawnFrogsNextFrame>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public FrogSpawnerPlugin <>4__this;

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

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

			[DebuggerHidden]
			public <SpawnFrogsNextFrame>d__15(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 = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.SpawnFrogs();
					<>4__this.AdjustSceneObjects();
					<>4__this.StartFlyingFrogs();
					return false;
				}
			}

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

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

		private static readonly Vector3 SpawnStart = new Vector3(-1f, 0f, -0.1f);

		private static readonly Vector3 SpawnEnd = new Vector3(1f, 0f, -0.1f);

		private const int FrogCount = 6;

		private const float FlyingFrogSpeed = 4f;

		private const float FlyingFrogMinDelay = 2f;

		private const float FlyingFrogMaxDelay = 16f;

		private static readonly Vector3[][] FlyingPaths = new Vector3[6][]
		{
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(24.06705f, -0.5842872f, 35.41306f),
				new Vector3(1.970011f, 7.385402f, 10.64797f),
				new Vector3(0.4526441f, 3.187652f, 2.077492f),
				new Vector3(1.377799f, 4f, -31.30668f)
			},
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(30.97688f, 3.5f, 14.72667f),
				new Vector3(2.386845f, 2.942744f, 8.766166f),
				new Vector3(-0.9452017f, 1.6f, -0.2742269f),
				new Vector3(-21.73576f, 3.5f, -15.7013f)
			},
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(-26.35768f, 3.5f, 23.15837f),
				new Vector3(-14.32157f, 1.7f, 15.20043f),
				new Vector3(0.612034f, 1.7f, 0.4132531f),
				new Vector3(8.599333f, 3.5f, -23.32863f)
			},
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(5.981702f, 27.50336f, 39.32086f),
				new Vector3(8.096831f, 4.002169f, 9.407063f),
				new Vector3(-0.9233425f, 1.8f, 0.6320488f),
				new Vector3(-6.05548f, 5f, -26.05625f)
			},
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(-21.05245f, 26.32257f, 32.06365f),
				new Vector3(-4.801445f, 1.8f, 9.406736f),
				new Vector3(0.8f, 1.8f, -0.8f),
				new Vector3(2.536873f, 5f, -26.63919f)
			},
			(Vector3[])(object)new Vector3[4]
			{
				new Vector3(-10.22455f, 16.4673f, 35.91084f),
				new Vector3(8.176137f, 2f, 12.30823f),
				new Vector3(0f, 2f, -0.5f),
				new Vector3(0.05196762f, 7f, -26.40484f)
			}
		};

		private GameObject _npcFrogPrefab;

		private GameObject _benchPrefab;

		private AudioClip _frogFlyingClip;

		private bool _spawned = false;

		private readonly List<Coroutine> _flyingCoroutines = new List<Coroutine>();

		private void Awake()
		{
			string text = Path.Combine(Paths.PluginPath, "ThatDRW-MVP_FroggedUpMenu", "mvp_dasfrog");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			if ((Object)(object)val == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to load AssetBundle from: " + text));
				return;
			}
			_npcFrogPrefab = val.LoadAsset<GameObject>("NpcFrog");
			if ((Object)(object)_npcFrogPrefab == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)"NpcFrog not found in mvp_dasfrog bundle.");
			}
			_benchPrefab = val.LoadAsset<GameObject>("dfk_bench_02_phys");
			if ((Object)(object)_benchPrefab == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"dfk_bench_02_phys not found in mvp_dasfrog bundle.");
			}
			if (!((Object)(object)_npcFrogPrefab == (Object)null))
			{
				_frogFlyingClip = val.LoadAsset<AudioClip>("frog_flying");
				if ((Object)(object)_frogFlyingClip == (Object)null)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"frog_flying audio clip not found in mvp_dasfrog bundle.");
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Assets loaded from bundle at: " + text));
				SceneManager.sceneLoaded += OnSceneLoaded;
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (((Scene)(ref scene)).name != "Menu")
			{
				StopFlyingCoroutines();
				_spawned = false;
			}
			else if (!_spawned)
			{
				_spawned = true;
				((MonoBehaviour)this).StartCoroutine(SpawnFrogsNextFrame());
			}
		}

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

		private void SpawnFrogs()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 6; i++)
			{
				float num = (float)i / 5f;
				Vector3 val = Vector3.Lerp(SpawnStart, SpawnEnd, num);
				GameObject val2 = Object.Instantiate<GameObject>(_npcFrogPrefab, val, Quaternion.identity);
				((Object)val2).name = $"NpcFrog_{i}";
				val2.SetActive(true);
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"Spawned {6} NpcFrogs between {SpawnStart} and {SpawnEnd}.");
		}

		private void AdjustSceneObjects()
		{
			//IL_001b: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, Vector3> dictionary = new Dictionary<string, Vector3>
			{
				{
					"SM_Menu_Vines_01 (3)",
					new Vector3(2.6311f, 1.3303f, -0.9621f)
				},
				{
					"SM_Menu_Vines_01 (1)",
					new Vector3(2.0543f, 0.6653f, -1.678f)
				},
				{
					"SM_Menu_Vines_01 (2)",
					new Vector3(-2.1414f, 1.072f, -1.1951f)
				},
				{
					"SM_Menu_Vines_01 (4)",
					new Vector3(-1.4795f, 0.5263f, -0.756f)
				}
			};
			foreach (KeyValuePair<string, Vector3> item in dictionary)
			{
				GameObject val = GameObject.Find(item.Key);
				if ((Object)(object)val != (Object)null)
				{
					val.transform.position = item.Value;
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"Repositioned {item.Key} to {item.Value}");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Scene object not found: " + item.Key));
				}
			}
		}

		private void StartFlyingFrogs()
		{
			for (int i = 0; i < FlyingPaths.Length; i++)
			{
				_flyingCoroutines.Add(((MonoBehaviour)this).StartCoroutine(FlyingFrogLoop(FlyingPaths[i], i)));
			}
		}

		private void StopFlyingCoroutines()
		{
			foreach (Coroutine flyingCoroutine in _flyingCoroutines)
			{
				if (flyingCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(flyingCoroutine);
				}
			}
			_flyingCoroutines.Clear();
		}

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

		[IteratorStateMachine(typeof(<FlyAlongPath>d__21))]
		private IEnumerator FlyAlongPath(GameObject frog, Vector3[] path, bool reverse)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FlyAlongPath>d__21(0)
			{
				<>4__this = this,
				frog = frog,
				path = path,
				reverse = reverse
			};
		}

		private void AddSmokeTrail(GameObject frog)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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_014b: Expected O, but got Unknown
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01c6: 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_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			GameObject val = new GameObject("SmokeTrail");
			val.transform.SetParent(frog.transform, false);
			val.transform.localPosition = Vector3.zero;
			ParticleSystem val2 = val.AddComponent<ParticleSystem>();
			val2.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = val2.main;
			((MainModule)(ref main)).loop = true;
			((MainModule)(ref main)).startLifetime = new MinMaxCurve(1.2f, 2.2f);
			((MainModule)(ref main)).startSpeed = new MinMaxCurve(0.3f, 0.8f);
			((MainModule)(ref main)).startSize = new MinMaxCurve(0.125f, 0.275f);
			((MainModule)(ref main)).simulationSpace = (ParticleSystemSimulationSpace)1;
			((MainModule)(ref main)).maxParticles = 500;
			((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(0.55f, 0f, 1f, 0.9f), new Color(0f, 0.9f, 0.5f, 0.9f));
			EmissionModule emission = val2.emission;
			((EmissionModule)(ref emission)).enabled = true;
			((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(62.5f);
			ShapeModule shape = val2.shape;
			((ShapeModule)(ref shape)).enabled = true;
			((ShapeModule)(ref shape)).shapeType = (ParticleSystemShapeType)0;
			((ShapeModule)(ref shape)).radius = 0.1f;
			SizeOverLifetimeModule sizeOverLifetime = val2.sizeOverLifetime;
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).enabled = true;
			AnimationCurve val3 = new AnimationCurve();
			val3.AddKey(0f, 0.4f);
			val3.AddKey(0.4f, 1f);
			val3.AddKey(1f, 0f);
			((SizeOverLifetimeModule)(ref sizeOverLifetime)).size = new MinMaxCurve(1f, val3);
			ColorOverLifetimeModule colorOverLifetime = val2.colorOverLifetime;
			((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled = true;
			Gradient val4 = new Gradient();
			val4.SetKeys((GradientColorKey[])(object)new GradientColorKey[3]
			{
				new GradientColorKey(new Color(0.55f, 0f, 1f), 0f),
				new GradientColorKey(new Color(0f, 0.9f, 0.5f), 0.5f),
				new GradientColorKey(new Color(0.8f, 0f, 0.8f), 1f)
			}, (GradientAlphaKey[])(object)new GradientAlphaKey[4]
			{
				new GradientAlphaKey(0f, 0f),
				new GradientAlphaKey(0.45f, 0.15f),
				new GradientAlphaKey(0.3f, 0.7f),
				new GradientAlphaKey(0f, 1f)
			});
			((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val4);
			NoiseModule noise = val2.noise;
			((NoiseModule)(ref noise)).enabled = true;
			((NoiseModule)(ref noise)).strength = MinMaxCurve.op_Implicit(0.6f);
			((NoiseModule)(ref noise)).frequency = 0.4f;
			((NoiseModule)(ref noise)).scrollSpeed = MinMaxCurve.op_Implicit(0.3f);
			((NoiseModule)(ref noise)).quality = (ParticleSystemNoiseQuality)1;
			ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
			((Renderer)component).material = new Material(Shader.Find("Particles/Standard Unlit"));
			component.renderMode = (ParticleSystemRenderMode)0;
			((Renderer)component).sortingOrder = 1;
			val2.Play();
		}

		private void AddFrogAudio(GameObject frog)
		{
			if (!((Object)(object)_frogFlyingClip == (Object)null))
			{
				AudioSource val = frog.AddComponent<AudioSource>();
				val.clip = _frogFlyingClip;
				val.loop = true;
				val.playOnAwake = false;
				val.volume = 0.8f;
				val.pitch = Random.Range(0.85f, 1.15f);
				val.spatialBlend = 1f;
				val.dopplerLevel = 1.5f;
				val.rolloffMode = (AudioRolloffMode)0;
				val.minDistance = 2f;
				val.maxDistance = 40f;
				val.Play();
			}
		}

		private static Vector3 CatmullRom(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3, float t)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_001f: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			return 0.5f * (2f * p1 + (-p0 + p2) * t + (2f * p0 - 5f * p1 + 4f * p2 - p3) * (t * t) + (-p0 + 3f * p1 - 3f * p2 + p3) * (t * t * t));
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
}