using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HutongGames.PlayMaker;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Silksong.FsmUtil.Actions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("silksong-modding")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) silksong-modding 2026")]
[assembly: AssemblyDescription("This is a library for mods to make FSM edits easier.")]
[assembly: AssemblyFileVersion("0.3.17.0")]
[assembly: AssemblyInformationalVersion("0.3.17+88121baa986322250c77a901834c0e259446a1dd")]
[assembly: AssemblyProduct("Silksong.FsmUtil")]
[assembly: AssemblyTitle("Silksong.FsmUtil")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/silksong-modding/Silksong.FsmUtil")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.17.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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")]
	[Embedded]
	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")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Silksong.FsmUtil
{
	public static class FsmUtil
	{
		[PublicAPI]
		public static PlayMakerFSM? GetFsm(this GameObject go, string fsmName)
		{
			PlayMakerFSM[] components = go.GetComponents<PlayMakerFSM>();
			foreach (PlayMakerFSM val in components)
			{
				if (val.FsmName == fsmName)
				{
					return val;
				}
			}
			return null;
		}

		[PublicAPI]
		public static PlayMakerFSM? GetFsmPreprocessed(this GameObject go, string fsmName)
		{
			PlayMakerFSM[] components = go.GetComponents<PlayMakerFSM>();
			foreach (PlayMakerFSM val in components)
			{
				if (val.FsmName == fsmName)
				{
					if (!val.Fsm.preprocessed)
					{
						val.Preprocess();
					}
					return val;
				}
			}
			return null;
		}

		private static TVal? GetItemFromArray<TVal>(TVal[] origArray, Func<TVal, bool> isItemCheck) where TVal : class
		{
			foreach (TVal val in origArray)
			{
				if (isItemCheck(val))
				{
					return val;
				}
			}
			return null;
		}

		private static TVal[] GetItemsFromArray<TVal>(TVal[] origArray, Func<TVal, bool> isItemCheck) where TVal : class
		{
			int num = 0;
			TVal[] array = origArray;
			foreach (TVal arg in array)
			{
				if (isItemCheck(arg))
				{
					num++;
				}
			}
			if (num == origArray.Length)
			{
				return origArray;
			}
			if (num == 0)
			{
				return Array.Empty<TVal>();
			}
			TVal[] array2 = new TVal[num];
			int num2 = 0;
			array = origArray;
			foreach (TVal val in array)
			{
				if (isItemCheck(val))
				{
					array2[num2] = val;
					num2++;
				}
			}
			return array2;
		}

		[PublicAPI]
		public static FsmState? GetState(this PlayMakerFSM fsm, string stateName)
		{
			return GetItemFromArray(fsm.FsmStates, (FsmState x) => x.Name == stateName);
		}

		[PublicAPI]
		public static FsmState? GetState(this Fsm fsm, string stateName)
		{
			return GetItemFromArray(fsm.States, (FsmState x) => x.Name == stateName);
		}

		[PublicAPI]
		public static FsmState MustGetState(this PlayMakerFSM fsm, string stateName)
		{
			return fsm.GetState(stateName) ?? throw new InvalidOperationException("State " + stateName + " not found in FSM " + fsm.FsmName);
		}

		[PublicAPI]
		public static FsmState MustGetState(this Fsm fsm, string stateName)
		{
			return fsm.GetState(stateName) ?? throw new InvalidOperationException("State " + stateName + " not found in FSM " + fsm.Name);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this PlayMakerFSM fsm, string stateName, string eventName)
		{
			return fsm.MustGetState(stateName).GetTransition(eventName);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this Fsm fsm, string stateName, string eventName)
		{
			return fsm.MustGetState(stateName).GetTransition(eventName);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this FsmState state, string eventName)
		{
			return GetItemFromArray(state.Transitions, (FsmTransition x) => x.EventName == eventName);
		}

		[PublicAPI]
		public static FsmTransition? GetGlobalTransition(this PlayMakerFSM fsm, string globalEventName)
		{
			return fsm.Fsm.GetGlobalTransition(globalEventName);
		}

		[PublicAPI]
		public static FsmTransition? GetGlobalTransition(this Fsm fsm, string globalEventName)
		{
			return GetItemFromArray(fsm.GlobalTransitions, (FsmTransition x) => x.EventName == globalEventName);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this PlayMakerFSM fsm, string stateName, int index) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetAction<TAction>(index);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this Fsm fsm, string stateName, int index) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetAction<TAction>(index);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this FsmState state, int index) where TAction : FsmStateAction
		{
			FsmStateAction obj = state.Actions[index];
			return (TAction)(object)((obj is TAction) ? obj : null);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).GetStateAction(index);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).GetStateAction(index);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this FsmState state, int index)
		{
			return state.Actions[index];
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetActionsOfType<TAction>();
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetActionsOfType<TAction>();
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			return Array.ConvertAll(GetItemsFromArray(state.Actions, (FsmStateAction x) => x is TAction), (FsmStateAction x) => (TAction)(object)x);
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			int num = state.IndexFirstActionOfType<TAction>();
			if (num == -1)
			{
				return default(TAction);
			}
			return state.GetAction<TAction>(num);
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.MustGetState(stateName).GetLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			int num = state.IndexLastActionOfType<TAction>();
			if (num == -1)
			{
				return default(TAction);
			}
			return state.GetAction<TAction>(num);
		}

		[PublicAPI]
		public static int IndexFirstActionMatching(this FsmState state, Func<FsmStateAction, bool> predicate)
		{
			int num = state.Actions.Length;
			for (int i = 0; i < num; i++)
			{
				if (predicate(state.Actions[i]))
				{
					return i;
				}
			}
			return -1;
		}

		[PublicAPI]
		public static int IndexLastActionMatching(this FsmState state, Func<FsmStateAction, bool> predicate)
		{
			for (int num = state.Actions.Length - 1; num >= 0; num--)
			{
				if (predicate(state.Actions[num]))
				{
					return num;
				}
			}
			return -1;
		}

		[PublicAPI]
		public static int IndexFirstActionOfType<T>(this FsmState state)
		{
			return state.IndexFirstActionMatching((FsmStateAction act) => act is T);
		}

		[PublicAPI]
		public static int IndexLastActionOfType<T>(this FsmState state)
		{
			return state.IndexLastActionMatching((FsmStateAction act) => act is T);
		}

		private static TVal[] AddItemToArray<TVal>(TVal[] origArray, TVal value)
		{
			TVal[] array = new TVal[origArray.Length + 1];
			origArray.CopyTo(array, 0);
			array[origArray.Length] = value;
			return array;
		}

		[PublicAPI]
		public static FsmState AddState(this PlayMakerFSM fsm, string stateName)
		{
			//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_001d: Expected O, but got Unknown
			return fsm.Fsm.AddState(new FsmState(fsm.Fsm)
			{
				Name = stateName
			});
		}

		[PublicAPI]
		public static FsmState AddState(this Fsm fsm, string stateName)
		{
			//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_0013: Expected O, but got Unknown
			return fsm.AddState(new FsmState(fsm)
			{
				Name = stateName
			});
		}

		[PublicAPI]
		public static FsmState AddState(this PlayMakerFSM fsm, FsmState state)
		{
			return fsm.Fsm.AddState(state);
		}

		[PublicAPI]
		public static FsmState AddState(this Fsm fsm, FsmState state)
		{
			FsmState[] states = fsm.States;
			FsmState[] array = (fsm.States = AddItemToArray(states, state));
			fsm.SaveActions();
			return array[states.Length];
		}

		[PublicAPI]
		public static FsmState CopyState(this PlayMakerFSM fsm, string fromState, string toState)
		{
			return fsm.Fsm.CopyState(fromState, toState);
		}

		[PublicAPI]
		public static FsmState CopyState(this Fsm fsm, string fromState, string toState)
		{
			//IL_0013: 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_0020: Expected O, but got Unknown
			FsmState state = fsm.GetState(fromState);
			if (state != null)
			{
				state.SaveActions();
			}
			FsmState val = new FsmState(state)
			{
				Name = toState
			};
			FsmTransition[] transitions = val.Transitions;
			foreach (FsmTransition val2 in transitions)
			{
				val2.ToFsmState = fsm.GetState(val2.ToState);
			}
			fsm.AddState(val);
			return val;
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this PlayMakerFSM fsm, string stateName, string eventName, string toState)
		{
			return fsm.MustGetState(stateName).AddTransition(eventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this Fsm fsm, string stateName, string eventName, string toState)
		{
			return fsm.MustGetState(stateName).AddTransition(eventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this FsmState state, string eventName, string toState)
		{
			//IL_000d: 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_0019: 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_0037: Expected O, but got Unknown
			FsmEvent fsmEvent = FsmEvent.GetFsmEvent(eventName);
			FsmTransition[] transitions = AddItemToArray(state.Transitions, new FsmTransition
			{
				ToState = toState,
				ToFsmState = state.Fsm.GetState(toState),
				FsmEvent = fsmEvent
			});
			state.Transitions = transitions;
			return fsmEvent;
		}

		[PublicAPI]
		public static FsmEvent AddGlobalTransition(this PlayMakerFSM fsm, string globalEventName, string toState)
		{
			return fsm.Fsm.AddGlobalTransition(globalEventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddGlobalTransition(this Fsm fsm, string globalEventName, string toState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0014: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			FsmEvent val = new FsmEvent(globalEventName)
			{
				IsGlobal = true
			};
			FsmTransition[] globalTransitions = AddItemToArray(fsm.GlobalTransitions, new FsmTransition
			{
				ToState = toState,
				ToFsmState = fsm.GetState(toState),
				FsmEvent = val
			});
			fsm.GlobalTransitions = globalTransitions;
			return val;
		}

		[PublicAPI]
		public static void AddAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action)
		{
			fsm.MustGetState(stateName).AddAction(action);
		}

		[PublicAPI]
		public static void AddAction(this Fsm fsm, string stateName, FsmStateAction action)
		{
			fsm.MustGetState(stateName).AddAction(action);
		}

		[PublicAPI]
		public static void AddAction(this FsmState state, FsmStateAction action)
		{
			FsmStateAction[] actions = AddItemToArray(state.Actions, action);
			state.Actions = actions;
			action.Init(state);
		}

		[PublicAPI]
		public static void AddActions(this PlayMakerFSM fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).AddActions(actions);
		}

		[PublicAPI]
		public static void AddActions(this Fsm fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).AddActions(actions);
		}

		[PublicAPI]
		public static void AddActions(this FsmState state, params FsmStateAction[] actions)
		{
			foreach (FsmStateAction action in actions)
			{
				state.AddAction(action);
			}
		}

		[PublicAPI]
		public static void AddMethod(this PlayMakerFSM fsm, string stateName, Action<FsmStateAction> method)
		{
			fsm.MustGetState(stateName).AddMethod(method);
		}

		[PublicAPI]
		public static void AddMethod(this Fsm fsm, string stateName, Action<FsmStateAction> method)
		{
			fsm.MustGetState(stateName).AddMethod(method);
		}

		[PublicAPI]
		public static void AddMethod(this FsmState state, Action<FsmStateAction> method)
		{
			DelegateAction<FsmStateAction> delegateAction = new DelegateAction<FsmStateAction>
			{
				Method = method
			};
			delegateAction.Arg = (FsmStateAction?)(object)delegateAction;
			state.AddAction((FsmStateAction)(object)delegateAction);
		}

		[PublicAPI]
		public static void AddMethod(this PlayMakerFSM fsm, string stateName, Action method, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).AddMethod(method, everyFrame);
		}

		[PublicAPI]
		public static void AddMethod(this Fsm fsm, string stateName, Action method, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).AddMethod(method, everyFrame);
		}

		[PublicAPI]
		public static void AddMethod(this FsmState state, Action method, bool everyFrame = false)
		{
			LambdaAction action = new LambdaAction
			{
				Method = method,
				EveryFrame = everyFrame
			};
			state.AddAction((FsmStateAction)(object)action);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this PlayMakerFSM fsm, string stateName, Action<Action> method)
		{
			fsm.MustGetState(stateName).AddLambdaMethod(method);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this Fsm fsm, string stateName, Action<Action> method)
		{
			fsm.MustGetState(stateName).AddLambdaMethod(method);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this FsmState state, Action<Action> method)
		{
			DelegateAction<Action> delegateAction = new DelegateAction<Action>
			{
				Method = method
			};
			delegateAction.Arg = ((FsmStateAction)delegateAction).Finish;
			state.AddAction((FsmStateAction)(object)delegateAction);
		}

		private static TVal[] InsertItemIntoArray<TVal>(TVal[] origArray, TVal value, int index)
		{
			int num = origArray.Length;
			if (index < 0 || index > num + 1)
			{
				throw new ArgumentOutOfRangeException($"Index {index} was out of range for array with length {num}!");
			}
			TVal[] array = new TVal[num + 1];
			for (int i = 0; i < index; i++)
			{
				array[i] = origArray[i];
			}
			array[index] = value;
			for (int i = index; i < num; i++)
			{
				array[i + 1] = origArray[i];
			}
			return array;
		}

		[PublicAPI]
		public static void InsertAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.MustGetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this PlayMakerFSM fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.MustGetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this Fsm fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.MustGetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this Fsm fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.MustGetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this FsmState state, FsmStateAction action, int index)
		{
			state.InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this FsmState state, int index, FsmStateAction action)
		{
			FsmStateAction[] actions = InsertItemIntoArray(state.Actions, action, index);
			state.Actions = actions;
			action.Init(state);
		}

		[PublicAPI]
		public static void InsertActions(this PlayMakerFSM fsm, string stateName, int index, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).InsertActions(index, actions);
		}

		[PublicAPI]
		public static void InsertActions(this Fsm fsm, string stateName, int index, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).InsertActions(index, actions);
		}

		[PublicAPI]
		public static void InsertActions(this FsmState state, int index, params FsmStateAction[] actions)
		{
			foreach (FsmStateAction action in actions)
			{
				state.InsertAction(action, index);
				index++;
			}
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, Action<FsmStateAction> method, int index)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, int index, Action<FsmStateAction> method)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, Action<FsmStateAction> method, int index)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, int index, Action<FsmStateAction> method)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, Action<FsmStateAction> method, int index)
		{
			state.InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, int index, Action<FsmStateAction> method)
		{
			DelegateAction<FsmStateAction> delegateAction = new DelegateAction<FsmStateAction>
			{
				Method = method
			};
			delegateAction.Arg = (FsmStateAction?)(object)delegateAction;
			state.InsertAction((FsmStateAction)(object)delegateAction, index);
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, Action method, int index, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method, everyFrame);
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, int index, Action method, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method, everyFrame);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, Action method, int index, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method, everyFrame);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, int index, Action method, bool everyFrame = false)
		{
			fsm.MustGetState(stateName).InsertMethod(index, method, everyFrame);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, Action method, int index, bool everyFrame = false)
		{
			state.InsertMethod(index, method, everyFrame);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, int index, Action method, bool everyFrame = false)
		{
			LambdaAction action = new LambdaAction
			{
				Method = method,
				EveryFrame = everyFrame
			};
			state.InsertAction((FsmStateAction)(object)action, index);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this PlayMakerFSM fsm, string stateName, Action<Action> method, int index)
		{
			fsm.MustGetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this PlayMakerFSM fsm, string stateName, int index, Action<Action> method)
		{
			fsm.MustGetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this Fsm fsm, string stateName, Action<Action> method, int index)
		{
			fsm.MustGetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this Fsm fsm, string stateName, int index, Action<Action> method)
		{
			fsm.MustGetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this FsmState state, Action<Action> method, int index)
		{
			state.InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this FsmState state, int index, Action<Action> method)
		{
			DelegateAction<Action> delegateAction = new DelegateAction<Action>
			{
				Method = method
			};
			delegateAction.Arg = ((FsmStateAction)delegateAction).Finish;
			state.InsertAction((FsmStateAction)(object)delegateAction, index);
		}

		[PublicAPI]
		public static void InsertMethodBefore(this FsmStateAction action, Action<FsmStateAction> method)
		{
			FsmState state = action.State;
			int index = Array.IndexOf(state.Actions, action);
			state.InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethodAfter(this FsmStateAction action, Action<FsmStateAction> method)
		{
			FsmState state = action.State;
			int num = Array.IndexOf(state.Actions, action);
			state.InsertMethod(num + 1, method);
		}

		[PublicAPI]
		public static void InsertMethodBefore(this FsmStateAction action, Action method)
		{
			FsmState state = action.State;
			int index = Array.IndexOf(state.Actions, action);
			state.InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethodAfter(this FsmStateAction action, Action method)
		{
			FsmState state = action.State;
			int num = Array.IndexOf(state.Actions, action);
			state.InsertMethod(num + 1, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethodBefore(this FsmStateAction action, Action<Action> method)
		{
			FsmState state = action.State;
			int index = Array.IndexOf(state.Actions, action);
			state.InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethodAfter(this FsmStateAction action, Action<Action> method)
		{
			FsmState state = action.State;
			int num = Array.IndexOf(state.Actions, action);
			state.InsertLambdaMethod(num + 1, method);
		}

		[PublicAPI]
		public static void InsertActionBefore(this FsmStateAction action, FsmStateAction newAction)
		{
			FsmState state = action.State;
			int index = Array.IndexOf(state.Actions, action);
			state.InsertAction(index, newAction);
		}

		[PublicAPI]
		public static void InsertActionAfter(this FsmStateAction action, FsmStateAction newAction)
		{
			FsmState state = action.State;
			int num = Array.IndexOf(state.Actions, action);
			state.InsertAction(num + 1, newAction);
		}

		[PublicAPI]
		public static void ReplaceAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.MustGetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this PlayMakerFSM fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.MustGetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this Fsm fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.MustGetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this Fsm fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.MustGetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this FsmState state, FsmStateAction action, int index)
		{
			state.ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this FsmState state, int index, FsmStateAction action)
		{
			state.Actions[index] = action;
			action.Init(state);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this PlayMakerFSM fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).ReplaceAllActions(actions);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this Fsm fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.MustGetState(stateName).ReplaceAllActions(actions);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this FsmState state, params FsmStateAction[] actions)
		{
			state.Actions = actions;
			for (int i = 0; i < actions.Length; i++)
			{
				actions[i].Init(state);
			}
		}

		[PublicAPI]
		public static void ReplaceActionsOfType<T>(this FsmState state, Func<T, FsmStateAction> newActionGenerator) where T : FsmStateAction
		{
			for (int i = 0; i < state.Actions.Length; i++)
			{
				FsmStateAction obj = state.Actions[i];
				T val = (T)(object)((obj is T) ? obj : null);
				if (val != null)
				{
					state.ReplaceAction(i, newActionGenerator(val));
				}
			}
		}

		[PublicAPI]
		public static void ReplaceFirstActionOfType<T>(this FsmState state, FsmStateAction newAction) where T : FsmStateAction
		{
			int num = -2;
			for (int i = 0; i < state.Actions.Length; i++)
			{
				if (state.Actions[i] is T)
				{
					num = i;
					break;
				}
			}
			if (num != -2)
			{
				state.ReplaceAction(newAction, num);
			}
		}

		[PublicAPI]
		public static void ReplaceLastActionOfType<T>(this FsmState state, FsmStateAction newAction) where T : FsmStateAction
		{
			int num = -2;
			for (int num2 = state.Actions.Length - 1; num2 >= 0; num2--)
			{
				if (state.Actions[num2] is T)
				{
					num = num2;
					break;
				}
			}
			if (num != -2)
			{
				state.ReplaceAction(newAction, num);
			}
		}

		[PublicAPI]
		public static bool ChangeTransition(this PlayMakerFSM fsm, string stateName, string eventName, string toState)
		{
			return fsm.MustGetState(stateName).ChangeTransition(eventName, toState);
		}

		[PublicAPI]
		public static bool ChangeTransition(this Fsm fsm, string stateName, string eventName, string toState)
		{
			return fsm.MustGetState(stateName).ChangeTransition(eventName, toState);
		}

		[PublicAPI]
		public static bool ChangeTransition(this FsmState state, string eventName, string toState)
		{
			FsmTransition transition = state.GetTransition(eventName);
			if (transition == null)
			{
				return false;
			}
			transition.ToState = toState;
			transition.ToFsmState = state.Fsm.GetState(toState);
			return true;
		}

		[PublicAPI]
		public static bool ChangeGlobalTransition(this PlayMakerFSM fsm, string globalEventName, string toState)
		{
			return fsm.Fsm.ChangeGlobalTransition(globalEventName, toState);
		}

		[PublicAPI]
		public static bool ChangeGlobalTransition(this Fsm fsm, string globalEventName, string toState)
		{
			FsmTransition globalTransition = fsm.GetGlobalTransition(globalEventName);
			if (globalTransition == null)
			{
				return false;
			}
			globalTransition.ToState = toState;
			globalTransition.ToFsmState = fsm.GetState(toState);
			return true;
		}

		private static TVal[] RemoveItemsFromArray<TVal>(TVal[] origArray, Func<TVal, bool> shouldBeRemovedCallback)
		{
			int num = 0;
			foreach (TVal arg in origArray)
			{
				if (shouldBeRemovedCallback(arg))
				{
					num++;
				}
			}
			if (num == 0)
			{
				return origArray;
			}
			TVal[] array = new TVal[origArray.Length - num];
			for (int num2 = origArray.Length - 1; num2 >= 0; num2--)
			{
				TVal val = origArray[num2];
				if (shouldBeRemovedCallback(val))
				{
					num--;
				}
				else
				{
					array[num2 - num] = val;
				}
			}
			return array;
		}

		[PublicAPI]
		public static void RemoveState(this PlayMakerFSM fsm, string stateName)
		{
			fsm.Fsm.RemoveState(stateName);
		}

		[PublicAPI]
		public static void RemoveState(this Fsm fsm, string stateName)
		{
			fsm.States = RemoveItemsFromArray(fsm.States, (FsmState x) => x.Name == stateName);
		}

		[PublicAPI]
		public static void RemoveTransition(this PlayMakerFSM fsm, string stateName, string eventName)
		{
			fsm.MustGetState(stateName).RemoveTransition(eventName);
		}

		[PublicAPI]
		public static void RemoveTransition(this Fsm fsm, string stateName, string eventName)
		{
			fsm.MustGetState(stateName).RemoveTransition(eventName);
		}

		[PublicAPI]
		public static void RemoveTransition(this FsmState state, string eventName)
		{
			state.Transitions = RemoveItemsFromArray(state.Transitions, (FsmTransition x) => x.EventName == eventName);
		}

		[PublicAPI]
		public static void RemoveGlobalTransition(this PlayMakerFSM fsm, string globalEventName)
		{
			fsm.Fsm.RemoveGlobalTransition(globalEventName);
		}

		[PublicAPI]
		public static void RemoveGlobalTransition(this Fsm fsm, string globalEventName)
		{
			fsm.GlobalTransitions = RemoveItemsFromArray(fsm.GlobalTransitions, (FsmTransition x) => x.EventName == globalEventName);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this PlayMakerFSM fsm, string toState)
		{
			fsm.Fsm.RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this Fsm fsm, string toState)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].RemoveTransitionsTo(toState);
			}
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this PlayMakerFSM fsm, string stateName, string toState)
		{
			fsm.MustGetState(stateName).RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this Fsm fsm, string stateName, string toState)
		{
			fsm.MustGetState(stateName).RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this FsmState state, string toState)
		{
			state.Transitions = RemoveItemsFromArray(state.Transitions, (FsmTransition x) => x.ToState == toState);
		}

		[PublicAPI]
		public static void RemoveTransitions(this PlayMakerFSM fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveTransitions();
		}

		[PublicAPI]
		public static void RemoveTransitions(this Fsm fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveTransitions();
		}

		[PublicAPI]
		public static void RemoveTransitions(this FsmState state)
		{
			state.Transitions = Array.Empty<FsmTransition>();
		}

		[PublicAPI]
		public static bool RemoveAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).RemoveAction(index);
		}

		[PublicAPI]
		public static bool RemoveAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).RemoveAction(index);
		}

		[PublicAPI]
		public static bool RemoveAction(this FsmState state, int index)
		{
			FsmStateAction[] actions = state.Actions;
			if (index < 0 || index >= actions.Length)
			{
				return false;
			}
			FsmStateAction[] array = (FsmStateAction[])(object)new FsmStateAction[actions.Length - 1];
			int num = array.Length;
			for (int i = 0; i < index; i++)
			{
				array[i] = actions[i];
			}
			for (int i = index; i < num; i++)
			{
				array[i] = actions[i + 1];
			}
			state.Actions = array;
			return true;
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this PlayMakerFSM fsm)
		{
			fsm.Fsm.RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this Fsm fsm)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].RemoveActionsOfType<TAction>();
			}
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this FsmState state)
		{
			state.Actions = RemoveItemsFromArray(state.Actions, (FsmStateAction x) => x is TAction);
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this FsmState state)
		{
			int num = state.IndexFirstActionOfType<TAction>();
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static void RemoveFirstActionMatching(this FsmState state, Func<FsmStateAction, bool> predicate)
		{
			int num = state.IndexFirstActionMatching(predicate);
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.MustGetState(stateName).RemoveLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this FsmState state)
		{
			int num = state.IndexLastActionOfType<TAction>();
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static void RemoveLastActionMatching(this FsmState state, Func<FsmStateAction, bool> predicate)
		{
			int num = state.IndexLastActionMatching(predicate);
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static bool DisableAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).DisableAction(index);
		}

		[PublicAPI]
		public static bool DisableAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.MustGetState(stateName).DisableAction(index);
		}

		[PublicAPI]
		public static bool DisableAction(this FsmState state, int index)
		{
			if (index < 0 || index >= state.Actions.Length)
			{
				return false;
			}
			state.Actions[index].Enabled = false;
			return true;
		}

		[PublicAPI]
		public static bool DisableActions(this PlayMakerFSM fsm, string stateName, params int[] indices)
		{
			return fsm.MustGetState(stateName).DisableActions(indices);
		}

		[PublicAPI]
		public static bool DisableActions(this Fsm fsm, string stateName, params int[] indices)
		{
			return fsm.MustGetState(stateName).DisableActions(indices);
		}

		[PublicAPI]
		public static bool DisableActions(this FsmState state, params int[] indices)
		{
			bool flag = true;
			foreach (int index in indices)
			{
				flag = flag && state.DisableAction(index);
			}
			return flag;
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this PlayMakerFSM fsm)
		{
			fsm.Fsm.DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this Fsm fsm)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].DisableActionsOfType<TAction>();
			}
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.MustGetState(stateName).DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.MustGetState(stateName).DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this FsmState state)
		{
			FsmStateAction[] actions = state.Actions;
			foreach (FsmStateAction val in actions)
			{
				if (val is TAction)
				{
					val.Enabled = false;
				}
			}
		}

		private static TVar[] MakeNewVariableArray<TVar>(TVar[] orig, string name) where TVar : NamedVariable, new()
		{
			TVar[] array = new TVar[orig.Length + 1];
			orig.CopyTo(array, 0);
			int num = orig.Length;
			TVar val = new TVar();
			((NamedVariable)val).name = name;
			array[num] = val;
			return array;
		}

		[PublicAPI]
		public static FsmFloat AddFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat AddFloatVariable(this Fsm fsm, string name)
		{
			FsmFloat[] array = MakeNewVariableArray<FsmFloat>(fsm.Variables.FloatVariables, name);
			fsm.Variables.FloatVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmInt AddIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt AddIntVariable(this Fsm fsm, string name)
		{
			FsmInt[] array = MakeNewVariableArray<FsmInt>(fsm.Variables.IntVariables, name);
			fsm.Variables.IntVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmBool AddBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool AddBoolVariable(this Fsm fsm, string name)
		{
			FsmBool[] array = MakeNewVariableArray<FsmBool>(fsm.Variables.BoolVariables, name);
			fsm.Variables.BoolVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmString AddStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddStringVariable(name);
		}

		[PublicAPI]
		public static FsmString AddStringVariable(this Fsm fsm, string name)
		{
			FsmString[] array = MakeNewVariableArray<FsmString>(fsm.Variables.StringVariables, name);
			fsm.Variables.StringVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmVector2 AddVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2 AddVector2Variable(this Fsm fsm, string name)
		{
			FsmVector2[] array = MakeNewVariableArray<FsmVector2>(fsm.Variables.Vector2Variables, name);
			fsm.Variables.Vector2Variables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmVector3 AddVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 AddVector3Variable(this Fsm fsm, string name)
		{
			FsmVector3[] array = MakeNewVariableArray<FsmVector3>(fsm.Variables.Vector3Variables, name);
			fsm.Variables.Vector3Variables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmRect AddRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect AddRectVariable(this Fsm fsm, string name)
		{
			FsmRect[] array = MakeNewVariableArray<FsmRect>(fsm.Variables.RectVariables, name);
			fsm.Variables.RectVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmQuaternion AddQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion AddQuaternionVariable(this Fsm fsm, string name)
		{
			FsmQuaternion[] array = MakeNewVariableArray<FsmQuaternion>(fsm.Variables.QuaternionVariables, name);
			fsm.Variables.QuaternionVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmColor AddColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor AddColorVariable(this Fsm fsm, string name)
		{
			FsmColor[] array = MakeNewVariableArray<FsmColor>(fsm.Variables.ColorVariables, name);
			fsm.Variables.ColorVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmGameObject AddGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject AddGameObjectVariable(this Fsm fsm, string name)
		{
			FsmGameObject[] array = MakeNewVariableArray<FsmGameObject>(fsm.Variables.GameObjectVariables, name);
			fsm.Variables.GameObjectVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmArray AddArrayVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddArrayVariable(name);
		}

		[PublicAPI]
		public static FsmArray AddArrayVariable(this Fsm fsm, string name)
		{
			FsmArray[] array = MakeNewVariableArray<FsmArray>(fsm.Variables.ArrayVariables, name);
			fsm.Variables.ArrayVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmEnum AddEnumVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddEnumVariable(name);
		}

		[PublicAPI]
		public static FsmEnum AddEnumVariable(this Fsm fsm, string name)
		{
			FsmEnum[] array = MakeNewVariableArray<FsmEnum>(fsm.Variables.EnumVariables, name);
			fsm.Variables.EnumVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmObject AddObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddObjectVariable(name);
		}

		[PublicAPI]
		public static FsmObject AddObjectVariable(this Fsm fsm, string name)
		{
			FsmObject[] array = MakeNewVariableArray<FsmObject>(fsm.Variables.ObjectVariables, name);
			fsm.Variables.ObjectVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmMaterial AddMaterialVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddMaterialVariable(name);
		}

		[PublicAPI]
		public static FsmMaterial AddMaterialVariable(this Fsm fsm, string name)
		{
			FsmMaterial[] array = MakeNewVariableArray<FsmMaterial>(fsm.Variables.MaterialVariables, name);
			fsm.Variables.MaterialVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		[PublicAPI]
		public static FsmTexture AddTextureVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddTextureVariable(name);
		}

		[PublicAPI]
		public static FsmTexture AddTextureVariable(this Fsm fsm, string name)
		{
			FsmTexture[] array = MakeNewVariableArray<FsmTexture>(fsm.Variables.TextureVariables, name);
			fsm.Variables.TextureVariables = array;
			fsm.Variables.AddVariableLookup((NamedVariable)(object)array[^1]);
			return array[^1];
		}

		private static TVar? FindInVariableArray<TVar>(TVar[] orig, string name) where TVar : NamedVariable, new()
		{
			foreach (TVar val in orig)
			{
				if (((NamedVariable)val).Name == name)
				{
					return val;
				}
			}
			return default(TVar);
		}

		[PublicAPI]
		public static FsmFloat? FindFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat? FindFloatVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmFloat>(fsm.Variables.FloatVariables, name);
		}

		[PublicAPI]
		public static FsmInt? FindIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt? FindIntVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmInt>(fsm.Variables.IntVariables, name);
		}

		[PublicAPI]
		public static FsmBool? FindBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool? FindBoolVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmBool>(fsm.Variables.BoolVariables, name);
		}

		[PublicAPI]
		public static FsmString? FindStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindStringVariable(name);
		}

		[PublicAPI]
		public static FsmString? FindStringVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmString>(fsm.Variables.StringVariables, name);
		}

		[PublicAPI]
		public static FsmVector2? FindVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2? FindVector2Variable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmVector2>(fsm.Variables.Vector2Variables, name);
		}

		[PublicAPI]
		public static FsmVector3? FindVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3? FindVector3Variable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmVector3>(fsm.Variables.Vector3Variables, name);
		}

		[PublicAPI]
		public static FsmRect? FindRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect? FindRectVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmRect>(fsm.Variables.RectVariables, name);
		}

		[PublicAPI]
		public static FsmQuaternion? FindQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion? FindQuaternionVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmQuaternion>(fsm.Variables.QuaternionVariables, name);
		}

		[PublicAPI]
		public static FsmColor? FindColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor? FindColorVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmColor>(fsm.Variables.ColorVariables, name);
		}

		[PublicAPI]
		public static FsmGameObject? FindGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject? FindGameObjectVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmGameObject>(fsm.Variables.GameObjectVariables, name);
		}

		[PublicAPI]
		public static FsmArray? FindArrayVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindArrayVariable(name);
		}

		[PublicAPI]
		public static FsmArray? FindArrayVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmArray>(fsm.Variables.ArrayVariables, name);
		}

		[PublicAPI]
		public static FsmEnum? FindEnumVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindEnumVariable(name);
		}

		[PublicAPI]
		public static FsmEnum? FindEnumVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmEnum>(fsm.Variables.EnumVariables, name);
		}

		[PublicAPI]
		public static FsmObject? FindObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindObjectVariable(name);
		}

		[PublicAPI]
		public static FsmObject? FindObjectVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmObject>(fsm.Variables.ObjectVariables, name);
		}

		[PublicAPI]
		public static FsmMaterial? FindMaterialVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindMaterialVariable(name);
		}

		[PublicAPI]
		public static FsmMaterial? FindMaterialVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmMaterial>(fsm.Variables.MaterialVariables, name);
		}

		[PublicAPI]
		public static FsmTexture? FindTextureVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindTextureVariable(name);
		}

		[PublicAPI]
		public static FsmTexture? FindTextureVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmTexture>(fsm.Variables.TextureVariables, name);
		}

		[PublicAPI]
		public static FsmFloat GetFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat GetFloatVariable(this Fsm fsm, string name)
		{
			FsmFloat val = fsm.FindFloatVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddFloatVariable(name);
		}

		[PublicAPI]
		public static FsmInt GetIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt GetIntVariable(this Fsm fsm, string name)
		{
			FsmInt val = fsm.FindIntVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddIntVariable(name);
		}

		[PublicAPI]
		public static FsmBool GetBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool GetBoolVariable(this Fsm fsm, string name)
		{
			FsmBool val = fsm.FindBoolVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddBoolVariable(name);
		}

		[PublicAPI]
		public static FsmString GetStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetStringVariable(name);
		}

		[PublicAPI]
		public static FsmString GetStringVariable(this Fsm fsm, string name)
		{
			FsmString val = fsm.FindStringVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddStringVariable(name);
		}

		[PublicAPI]
		public static FsmVector2 GetVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2 GetVector2Variable(this Fsm fsm, string name)
		{
			FsmVector2 val = fsm.FindVector2Variable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 GetVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 GetVector3Variable(this Fsm fsm, string name)
		{
			FsmVector3 val = fsm.FindVector3Variable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddVector3Variable(name);
		}

		[PublicAPI]
		public static FsmRect GetRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect GetRectVariable(this Fsm fsm, string name)
		{
			FsmRect val = fsm.FindRectVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddRectVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion GetQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion GetQuaternionVariable(this Fsm fsm, string name)
		{
			FsmQuaternion val = fsm.FindQuaternionVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmColor GetColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor GetColorVariable(this Fsm fsm, string name)
		{
			FsmColor val = fsm.FindColorVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddColorVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject GetGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject GetGameObjectVariable(this Fsm fsm, string name)
		{
			FsmGameObject val = fsm.FindGameObjectVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmArray GetArrayVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetArrayVariable(name);
		}

		[PublicAPI]
		public static FsmArray GetArrayVariable(this Fsm fsm, string name)
		{
			FsmArray val = fsm.FindArrayVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddArrayVariable(name);
		}

		[PublicAPI]
		public static FsmEnum GetEnumVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetEnumVariable(name);
		}

		[PublicAPI]
		public static FsmEnum GetEnumVariable(this Fsm fsm, string name)
		{
			FsmEnum val = fsm.FindEnumVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddEnumVariable(name);
		}

		[PublicAPI]
		public static FsmObject GetObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetObjectVariable(name);
		}

		[PublicAPI]
		public static FsmObject GetObjectVariable(this Fsm fsm, string name)
		{
			FsmObject val = fsm.FindObjectVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddObjectVariable(name);
		}

		[PublicAPI]
		public static FsmMaterial GetMaterialVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetMaterialVariable(name);
		}

		[PublicAPI]
		public static FsmMaterial GetMaterialVariable(this Fsm fsm, string name)
		{
			FsmMaterial val = fsm.FindMaterialVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddMaterialVariable(name);
		}

		[PublicAPI]
		public static FsmTexture GetTextureVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetTextureVariable(name);
		}

		[PublicAPI]
		public static FsmTexture GetTextureVariable(this Fsm fsm, string name)
		{
			FsmTexture val = fsm.FindTextureVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddTextureVariable(name);
		}

		[PublicAPI]
		public static void MakeLog(this PlayMakerFSM fsm, bool additionalLogging = false)
		{
			fsm.Fsm.MakeLog(additionalLogging);
		}

		[PublicAPI]
		public static void MakeLog(this Fsm fsm, bool additionalLogging = false)
		{
			FsmState[] states = fsm.States;
			foreach (FsmState val in states)
			{
				for (int num = val.Actions.Length - 1; num >= 0; num--)
				{
					fsm.InsertAction(val.Name, (FsmStateAction)(object)new LogAction
					{
						Text = FsmString.op_Implicit($"{num} - {((object)val.Actions[num]).GetType().FullName}")
					}, num);
					if (additionalLogging)
					{
						fsm.InsertMethod(val.Name, delegate
						{
							//IL_018c: Unknown result type (might be due to invalid IL or missing references)
							//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
							//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
							//IL_0212: Unknown result type (might be due to invalid IL or missing references)
							//IL_0226: Unknown result type (might be due to invalid IL or missing references)
							//IL_0276: Unknown result type (might be due to invalid IL or missing references)
							//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
							//IL_030a: Unknown result type (might be due to invalid IL or missing references)
							FsmVariables variables = fsm.Variables;
							FsmFloat[] floatVariables = variables.FloatVariables;
							foreach (FsmFloat val2 in floatVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[FloatVariables] - '{((NamedVariable)val2).Name}': '{val2.Value}'");
							}
							FsmInt[] intVariables = variables.IntVariables;
							foreach (FsmInt val3 in intVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[IntVariables] - '{((NamedVariable)val3).Name}': '{val3.Value}'");
							}
							FsmBool[] boolVariables = variables.BoolVariables;
							foreach (FsmBool val4 in boolVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[BoolVariables] - '{((NamedVariable)val4).Name}': '{val4.Value}'");
							}
							FsmString[] stringVariables = variables.StringVariables;
							foreach (FsmString val5 in stringVariables)
							{
								InternalLogger.Log("[" + fsm.Name + "]:[StringVariables] - '" + ((NamedVariable)val5).Name + "': '" + val5.Value + "'");
							}
							FsmVector2[] vector2Variables = variables.Vector2Variables;
							foreach (FsmVector2 val6 in vector2Variables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[Vector2Variables] - '{((NamedVariable)val6).Name}': '({val6.Value.x}, {val6.Value.y})'");
							}
							FsmVector3[] vector3Variables = variables.Vector3Variables;
							foreach (FsmVector3 val7 in vector3Variables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[Vector3Variables] - '{((NamedVariable)val7).Name}': '({val7.Value.x}, {val7.Value.y}, {val7.Value.z})'");
							}
							FsmRect[] rectVariables = variables.RectVariables;
							foreach (FsmRect val8 in rectVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[RectVariables] - '{((NamedVariable)val8).Name}': '{val8.Value}'");
							}
							FsmQuaternion[] quaternionVariables = variables.QuaternionVariables;
							foreach (FsmQuaternion val9 in quaternionVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[QuaternionVariables] - '{((NamedVariable)val9).Name}': '{val9.Value}'");
							}
							FsmColor[] colorVariables = variables.ColorVariables;
							foreach (FsmColor val10 in colorVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[ColorVariables] - '{((NamedVariable)val10).Name}': '{val10.Value}'");
							}
							FsmGameObject[] gameObjectVariables = variables.GameObjectVariables;
							foreach (FsmGameObject val11 in gameObjectVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[GameObjectVariables] - '{((NamedVariable)val11).Name}': '{val11.Value}'");
							}
							FsmArray[] arrayVariables = variables.ArrayVariables;
							foreach (FsmArray val12 in arrayVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[ArrayVariables] - '{((NamedVariable)val12).Name}': '{val12}'");
							}
							FsmEnum[] enumVariables = variables.EnumVariables;
							foreach (FsmEnum val13 in enumVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[EnumVariables] - '{((NamedVariable)val13).Name}': '{val13.Value}'");
							}
							FsmObject[] objectVariables = variables.ObjectVariables;
							foreach (FsmObject val14 in objectVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[ObjectVariables] - '{((NamedVariable)val14).Name}': '{val14.Value}'");
							}
							FsmMaterial[] materialVariables = variables.MaterialVariables;
							foreach (FsmMaterial val15 in materialVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[MaterialVariables] - '{((NamedVariable)val15).Name}': '{val15.Value}'");
							}
							FsmTexture[] textureVariables = variables.TextureVariables;
							foreach (FsmTexture val16 in textureVariables)
							{
								InternalLogger.Log($"[{fsm.Name}]:[TextureVariables] - '{((NamedVariable)val16).Name}': '{val16.Value}'");
							}
						}, num + 1, everyFrame: false);
					}
				}
			}
		}

		[PublicAPI]
		public static void Log(this PlayMakerFSM fsm)
		{
			fsm.Fsm.Log(((Object)((Component)fsm).gameObject).name);
		}

		[PublicAPI]
		public static void Log(this Fsm fsm, string gameObjectName = "")
		{
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			Log("FSM \"" + fsm.Name + "\" on \"" + gameObjectName + "\"");
			Log($"\t{fsm.States.Length} States");
			FsmState[] states = fsm.States;
			FsmTransition[] transitions;
			foreach (FsmState val in states)
			{
				Log("\t\tState \"" + val.Name + "\"");
				transitions = val.Transitions;
				foreach (FsmTransition val2 in transitions)
				{
					Log("\t\t\t-> \"" + val2.ToState + "\" via \"" + val2.EventName + "\"");
				}
			}
			Log($"\t{fsm.GlobalTransitions.Length} Global Transitions");
			transitions = fsm.GlobalTransitions;
			foreach (FsmTransition val3 in transitions)
			{
				Log("\t\tGlobal Transition \"" + val3.EventName + "\" to \"" + val3.ToState + "\"");
			}
			Log("\tVariables");
			FsmVariables variables = fsm.Variables;
			FsmFloat[] floatVariables = variables.FloatVariables;
			foreach (FsmFloat val4 in floatVariables)
			{
				Log($"\t\tFloat \"{((NamedVariable)val4).Name}\": {val4.Value}");
			}
			FsmInt[] intVariables = variables.IntVariables;
			foreach (FsmInt val5 in intVariables)
			{
				Log($"\t\tInt \"{((NamedVariable)val5).Name}\": {val5.Value}");
			}
			FsmBool[] boolVariables = variables.BoolVariables;
			foreach (FsmBool val6 in boolVariables)
			{
				Log($"\t\tBool \"{((NamedVariable)val6).Name}\": {val6.Value}");
			}
			FsmString[] stringVariables = variables.StringVariables;
			foreach (FsmString val7 in stringVariables)
			{
				Log("\t\tString \"" + ((NamedVariable)val7).Name + "\": " + val7.Value);
			}
			FsmVector2[] vector2Variables = variables.Vector2Variables;
			foreach (FsmVector2 val8 in vector2Variables)
			{
				Log($"\t\tVector2 \"{((NamedVariable)val8).Name}\": {val8.Value}");
			}
			FsmVector3[] vector3Variables = variables.Vector3Variables;
			foreach (FsmVector3 val9 in vector3Variables)
			{
				Log($"\t\tVector3 \"{((NamedVariable)val9).Name}\": {val9.Value}");
			}
			FsmRect[] rectVariables = variables.RectVariables;
			foreach (FsmRect val10 in rectVariables)
			{
				Log($"\t\tRect \"{((NamedVariable)val10).Name}\": {val10.Value}");
			}
			FsmQuaternion[] quaternionVariables = variables.QuaternionVariables;
			foreach (FsmQuaternion val11 in quaternionVariables)
			{
				Log($"\t\tQuaternion \"{((NamedVariable)val11).Name}\": {val11.Value}");
			}
			FsmColor[] colorVariables = variables.ColorVariables;
			foreach (FsmColor val12 in colorVariables)
			{
				Log($"\t\tColor \"{((NamedVariable)val12).Name}\": {val12.Value}");
			}
			FsmGameObject[] gameObjectVariables = variables.GameObjectVariables;
			foreach (FsmGameObject val13 in gameObjectVariables)
			{
				Log($"\t\tGameObject \"{((NamedVariable)val13).Name}\": {val13.Value}");
			}
			FsmArray[] arrayVariables = variables.ArrayVariables;
			foreach (FsmArray val14 in arrayVariables)
			{
				string[] obj = new string[5]
				{
					"\t\tArray \"",
					((NamedVariable)val14).Name,
					"\": \"",
					null,
					null
				};
				object[] objectReferences = val14.objectReferences;
				obj[3] = string.Join(", ", objectReferences);
				obj[4] = "\"";
				Log(string.Concat(obj));
			}
			FsmEnum[] enumVariables = variables.EnumVariables;
			foreach (FsmEnum val15 in enumVariables)
			{
				Log($"\t\tEnum \"{((NamedVariable)val15).Name}\": {val15.Value}");
			}
			FsmObject[] objectVariables = variables.ObjectVariables;
			foreach (FsmObject val16 in objectVariables)
			{
				Log($"\t\tObject \"{((NamedVariable)val16).Name}\": {val16.Value}");
			}
			FsmMaterial[] materialVariables = variables.MaterialVariables;
			foreach (FsmMaterial val17 in materialVariables)
			{
				Log($"\t\tMaterial \"{((NamedVariable)val17).Name}\": {val17.Value}");
			}
			FsmTexture[] textureVariables = variables.TextureVariables;
			foreach (FsmTexture val18 in textureVariables)
			{
				Log($"\t\tTexture \"{((NamedVariable)val18).Name}\": {val18.Value}");
			}
		}

		private static void Log(string goName, string fsmName, string part, string msg)
		{
			Log("[" + goName + "]:[" + fsmName + "]:[" + part + "]", msg);
		}

		private static void Log(string msg)
		{
			Log("[Core]:[FsmUtil]:[FsmUtil]", msg);
		}

		private static void Log(string pre, string post)
		{
			InternalLogger.Log(pre + " - " + post);
		}
	}
	internal static class InternalLogger
	{
		internal static ManualLogSource? Logger;

		internal static void LogFine(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogDebug((object)message);
			}
		}

		internal static void LogDebug(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
		}

		internal static void Log(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogMessage((object)message);
			}
		}

		internal static void LogWarn(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogWarning((object)message);
			}
		}

		internal static void LogError(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogError((object)message);
			}
		}

		internal static void LogFatal(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogFatal((object)message);
			}
		}
	}
	[BepInPlugin("org.silksong-modding.fsmutil", "Silksong.FsmUtil", "0.3.17")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "org.silksong-modding.fsmutil";

		public static string Name => "Silksong.FsmUtil";

		public static string Version => "0.3.17";

		private void Awake()
		{
			InternalLogger.Logger = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (org.silksong-modding.fsmutil) has loaded!"));
		}
	}
}
namespace Silksong.FsmUtil.Actions
{
	public class DelegateAction<TArg> : FsmStateAction
	{
		public Action<TArg>? Method;

		public TArg? Arg;

		public override void Reset()
		{
			Method = null;
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			if (Method != null && Arg != null)
			{
				Method(Arg);
			}
			if (!(Arg is Action action) || action != new Action(base.Finish))
			{
				((FsmStateAction)this).Finish();
			}
		}
	}
	public class LambdaAction : FsmStateAction
	{
		public Action? Method;

		public bool EveryFrame;

		public override void Reset()
		{
			Method = null;
			EveryFrame = false;
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			if (Method != null)
			{
				Method();
			}
			if (!EveryFrame)
			{
				((FsmStateAction)this).Finish();
			}
		}

		public override void OnUpdate()
		{
			if (EveryFrame && Method != null)
			{
				Method();
			}
		}
	}
	public class LogAction : SimpleLogAction
	{
		public override void OnEnter()
		{
			if (Text.Value != null)
			{
				Log(Text.Value ?? "");
			}
			((FsmStateAction)this).Finish();
		}

		private void Log(string message)
		{
			string text = ((FsmStateAction)this).Fsm.GameObjectName;
			Transform parent = ((FsmStateAction)this).Fsm.GameObject.transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)((Component)parent).gameObject).name + "/" + text;
				parent = parent.parent;
			}
			InternalLogger.Log("[" + text + "]:[" + ((FsmStateAction)this).Fsm.Name + "]:[" + ((FsmStateAction)this).State.Name + "] - " + message);
		}
	}
	public class SimpleLogAction : FsmStateAction
	{
		public FsmString Text;

		public override void Reset()
		{
			Text = FsmString.op_Implicit(string.Empty);
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			if (Text.Value != null)
			{
				Log("FSM Log: \"" + Text.Value + "\"");
			}
			((FsmStateAction)this).Finish();
		}

		private static void Log(string message)
		{
			InternalLogger.Log("[Core]:[FsmUtil]:[LogAction] - " + message);
		}
	}
}