using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using AssetsTools.NET;
using AssetsTools.NET.Extra;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using R2API.Animations.Models.Interfaces;
using R2API.AutoVersionGen;
using R2API.Models;
using R2API.NativeStructs;
using RoR2;
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("R2API.Animations")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+4c3fa0aa1bf06bccbf6fd22f858a2b3d0c968b1c")]
[assembly: AssemblyProduct("R2API.Animations")]
[assembly: AssemblyTitle("R2API.Animations")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[assembly: TypeForwardedTo(typeof(Condition))]
[assembly: TypeForwardedTo(typeof(ConditionMode))]
[assembly: TypeForwardedTo(typeof(Parameter))]
[assembly: TypeForwardedTo(typeof(ParameterType))]
[assembly: TypeForwardedTo(typeof(ParameterValue))]
[assembly: TypeForwardedTo(typeof(State))]
[assembly: TypeForwardedTo(typeof(Transition))]
[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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

		public NativeIntegerAttribute(bool[] P_0)
		{
			TransformFlags = 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 System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	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]
	[DebuggerNonUserCode]
	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;
		}
	}
}
namespace R2API
{
	[AutoVersion]
	public static class AnimationsAPI
	{
		public const string PluginGUID = "com.bepis.r2api.animations";

		public const string PluginName = "R2API.Animations";

		private const string bundleExtension = ".bundle";

		private const string hashExtension = ".hash";

		private const string dummyBundleName = "dummy_controller_bundle";

		private const long dummyAnimatorControllerPathID = -27250459394986890L;

		private const string dummyAnimatorControllerPath = "assets/dummycontroller.controller";

		private static readonly Dictionary<(string, RuntimeAnimatorController), List<AnimatorModifications>> controllerModifications = new Dictionary<(string, RuntimeAnimatorController), List<AnimatorModifications>>();

		private static readonly Dictionary<RuntimeAnimatorController, List<Animator>> controllerToAnimators = new Dictionary<RuntimeAnimatorController, List<Animator>>();

		private static bool _hooksEnabled = false;

		public const string PluginVersion = "1.2.0";

		internal static void SetHooks()
		{
			if (!_hooksEnabled)
			{
				RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(OnLoad));
				_hooksEnabled = true;
			}
		}

		internal static void UnsetHooks()
		{
			RoR2Application.onLoad = (Action)Delegate.Remove(RoR2Application.onLoad, new Action(OnLoad));
			_hooksEnabled = false;
		}

		private static void OnLoad()
		{
			NativeHelpers.Init();
			ApplyModifications();
		}

		public static void AddModifications(string sourceBundlePath, RuntimeAnimatorController sourceAnimatorController, AnimatorModifications modifications)
		{
			SetHooks();
			controllerModifications.GetOrAddDefault((sourceBundlePath, sourceAnimatorController), () => new List<AnimatorModifications>()).Add(modifications);
		}

		public static void AddAnimatorController(Animator animator, RuntimeAnimatorController controller)
		{
			SetHooks();
			controllerToAnimators.GetOrAddDefault(controller, () => new List<Animator>()).Add(animator);
		}

		internal static void ApplyModifications()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			AssetsManager val = new AssetsManager();
			string text = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)AnimationsPlugin.Instance).Info.Location), "dummy_controller_bundle");
			foreach (KeyValuePair<(string, RuntimeAnimatorController), List<AnimatorModifications>> controllerModification in controllerModifications)
			{
				controllerModification.Deconstruct(out var key, out var value);
				(string, RuntimeAnimatorController) tuple = key;
				string item = tuple.Item1;
				RuntimeAnimatorController item2 = tuple.Item2;
				List<AnimatorModifications> modifications = value;
				long assetPathID = NativeHelpers.GetAssetPathID((Object)(object)item2);
				string text2 = Path.Combine(Paths.CachePath, "R2API.Animations", string.Format("{0}_{1}{2}", Path.GetFileName(item), assetPathID, ".bundle"));
				string text3 = Path.Combine(Paths.CachePath, "R2API.Animations", string.Format("{0}_{1}{2}", Path.GetFileName(item), assetPathID, ".hash"));
				bool value2 = AnimationsPlugin.IgnoreCache.Value;
				string hash = null;
				if (value2 || !CachedBundleExists(text2, text3, assetPathID, modifications, out hash))
				{
					BundleFileInstance val2 = val.LoadBundleFile(item, true);
					AssetsFileInstance assetFile = val.LoadAssetsFileFromBundle(val2, 0, false);
					BundleFileInstance val3 = val.LoadBundleFile(text, true);
					AssetsFileInstance val4 = val.LoadAssetsFileFromBundle(val3, 0, false);
					new ModificationsBundleCreator(val, assetFile, assetPathID, val4, val3, -27250459394986890L, modifications, text2).Run();
					if (!value2)
					{
						File.WriteAllText(text3, hash);
					}
					val.UnloadAssetsFile(val4);
					val.UnloadBundleFile(val3);
				}
				RuntimeAnimatorController runtimeAnimatorController = AssetBundle.LoadFromFile(text2).LoadAsset<RuntimeAnimatorController>("assets/dummycontroller.controller");
				if (!controllerToAnimators.TryGetValue(item2, out List<Animator> value3))
				{
					continue;
				}
				foreach (Animator item3 in value3)
				{
					item3.runtimeAnimatorController = runtimeAnimatorController;
				}
			}
			val.UnloadAll(true);
			controllerModifications.Clear();
			controllerToAnimators.Clear();
		}

		private static bool CachedBundleExists(string modifiedBundlePath, string hashPath, long sourceAnimatorControllerPathID, List<AnimatorModifications> modifications, out string hash)
		{
			using (MD5 mD = MD5.Create())
			{
				using MemoryStream memoryStream = new MemoryStream();
				using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
				binaryWriter.Write(RoR2Application.buildId);
				binaryWriter.Write(sourceAnimatorControllerPathID);
				foreach (AnimatorModifications item in modifications.OrderBy((AnimatorModifications m) => m.Key))
				{
					binaryWriter.Write(item.Key);
				}
				byte[] array = mD.ComputeHash(memoryStream);
				hash = BitConverter.ToString(array);
			}
			if (!File.Exists(modifiedBundlePath))
			{
				return false;
			}
			if (!File.Exists(hashPath))
			{
				return false;
			}
			string text = File.ReadAllText(hashPath);
			return hash == text;
		}
	}
	[BepInPlugin("com.bepis.r2api.animations", "R2API.Animations", "1.2.0")]
	public sealed class AnimationsPlugin : BaseUnityPlugin
	{
		internal static AnimationsPlugin Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static ConfigEntry<bool> IgnoreCache { get; private set; }

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			IgnoreCache = ((BaseUnityPlugin)this).Config.Bind<bool>("Dev", "IgnoreCache", false, "Always generate new bundles with modifications");
		}

		private void OnDestroy()
		{
			AnimationsAPI.UnsetHooks();
		}
	}
	public class AnimatorModifications : IExistingAnimatorController
	{
		public string Key { get; }

		public Dictionary<string, List<State>> NewStates { get; } = new Dictionary<string, List<State>>();


		public Dictionary<(string, string), List<Transition>> NewTransitions { get; } = new Dictionary<(string, string), List<Transition>>();


		public List<Parameter> NewParameters { get; } = new List<Parameter>();


		IReadOnlyList<IParameter> IExistingAnimatorController.NewParameters => (IReadOnlyList<IParameter>)NewParameters;

		public List<ExistingLayer> Layers { get; } = new List<ExistingLayer>();


		IReadOnlyList<IExistingLayer> IExistingAnimatorController.Layers => (IReadOnlyList<IExistingLayer>)Layers;

		public List<Layer> NewLayers { get; } = new List<Layer>();


		IReadOnlyList<ILayer> IExistingAnimatorController.NewLayers => (IReadOnlyList<ILayer>)NewLayers;

		public AnimatorModifications(BepInPlugin plugin)
		{
			Key = $"{plugin.GUID};{plugin.Version}";
		}

		[Obsolete]
		public static AnimatorModifications CreateFromDiff(AnimatorDiff diff, BepInPlugin plugin, string clipBundlePath)
		{
			return CreateFromDiff(diff, plugin);
		}

		public static AnimatorModifications CreateFromDiff(AnimatorDiff diff, BepInPlugin plugin)
		{
			AnimatorModifications animatorModifications = new AnimatorModifications(plugin);
			animatorModifications.Layers.AddRange(diff.Layers);
			animatorModifications.NewLayers.AddRange(diff.NewLayers);
			animatorModifications.NewParameters.AddRange(diff.NewParameters);
			foreach (ExistingLayer layer in diff.Layers)
			{
				animatorModifications.NewStates[layer.Name] = layer.NewStates;
				foreach (ExistingState existingState in layer.ExistingStates)
				{
					animatorModifications.NewTransitions[(layer.Name, existingState.Name)] = existingState.NewTransitions;
				}
			}
			return animatorModifications;
		}
	}
	internal static class Extensions
	{
		public static TValue GetOrAddDefault<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, Func<TValue> defaultValueFunc)
		{
			if (dict.TryGetValue(key, out TValue value))
			{
				return value;
			}
			return dict[key] = defaultValueFunc();
		}

		public static int IndexOf<T>(this IEnumerable<T> values, Func<T, bool> predicate)
		{
			int result = 0;
			foreach (T value in values)
			{
				if (predicate(value))
				{
					return result;
				}
			}
			return -1;
		}
	}
	internal class ModificationsBundleCreator
	{
		private class BehavioursNode
		{
			public uint FullPathID;

			public string FullPath;

			public bool IsState;

			public BehavioursNode Parent;

			public List<uint> Behaviours = new List<uint>();
		}

		private readonly AssetsManager manager;

		private readonly AssetsFileInstance assetFile;

		private readonly long sourceAnimatorControllerPathID;

		private readonly AssetsFileInstance dummyAssetFile;

		private readonly BundleFileInstance dummyBundleFile;

		private readonly long dummyAnimatorControllerPathID;

		private readonly List<AnimatorModifications> modifications;

		private readonly string modifiedBundlePath;

		private readonly List<string> dependencies = new List<string>();

		private readonly List<string> newNames = new List<string>();

		private readonly Dictionary<uint, string> hashToName = new Dictionary<uint, string>();

		private readonly Dictionary<string, uint> nameToHash = new Dictionary<string, uint>();

		private readonly List<Action> delayedActions = new List<Action>();

		private AssetTypeValueField baseField;

		private AnimatorModifications currentModification;

		private void AddBehaviours()
		{
			AssetTypeValueField obj = baseField["m_Controller"];
			AssetTypeValueField val = obj["m_LayerArray"]["Array"];
			AssetTypeValueField stateMachineArray = obj["m_StateMachineArray"]["Array"];
			GatherLayerBehaviourNodes(val, stateMachineArray, out List<Dictionary<uint, BehavioursNode>> layerBehaviourNodes);
			AssetTypeValueField val2 = baseField["m_StateMachineBehaviours"]["Array"];
			AssetTypeValueField obj2 = baseField["m_StateMachineBehaviourVectorDescription"];
			AssetTypeValueField val3 = obj2["m_StateMachineBehaviourRanges"]["Array"];
			AssetTypeValueField val4 = obj2["m_StateMachineBehaviourIndices"]["Array"];
			List<(int, long)> list = new List<(int, long)>();
			Dictionary<StateMachineBehaviour, uint> addedBehaviours = new Dictionary<StateMachineBehaviour, uint>();
			foreach (AssetTypeValueField item3 in val2)
			{
				list.Add((item3["m_FileID"].AsInt, item3["m_PathID"].AsLong));
			}
			List<(uint, int, List<uint>)> list2 = new List<(uint, int, List<uint>)>();
			foreach (AssetTypeValueField item4 in val3)
			{
				AssetTypeValueField obj3 = item4["first"];
				uint asUInt = obj3["m_LayerIndex"].AsUInt;
				uint asUInt2 = obj3["m_StateID"].AsUInt;
				AssetTypeValueField obj4 = item4["second"];
				int asUInt3 = (int)obj4["m_StartIndex"].AsUInt;
				uint asUInt4 = obj4["m_Count"].AsUInt;
				if (layerBehaviourNodes[(int)asUInt].TryGetValue(asUInt2, out var value))
				{
					for (int i = 0; i < asUInt4; i++)
					{
						value.Behaviours.Add(val4[i + asUInt3].AsUInt);
					}
					continue;
				}
				List<uint> list3 = new List<uint>();
				for (int j = 0; j < asUInt4; j++)
				{
					list3.Add(val4[j + asUInt3].AsUInt);
				}
				list2.Add((asUInt2, (int)asUInt, list3));
			}
			foreach (Dictionary<uint, BehavioursNode> item5 in layerBehaviourNodes)
			{
				foreach (BehavioursNode item6 in item5.Values.Where((BehavioursNode v) => v.IsState))
				{
					for (BehavioursNode parent = item6.Parent; parent != null; parent = parent.Parent)
					{
						foreach (uint behaviour in parent.Behaviours)
						{
							item6.Behaviours.Remove(behaviour);
						}
					}
				}
			}
			foreach (AnimatorModifications modification in modifications)
			{
				AnimatorModifications animatorModifications = (currentModification = modification);
				foreach (ExistingLayer layer in animatorModifications.Layers)
				{
					uint layerID2 = GetOrAddName(layer.Name);
					int num = ((IEnumerable<AssetTypeValueField>)val).IndexOf((AssetTypeValueField l) => l["data"]["m_Binding"].AsUInt == layerID2);
					Dictionary<uint, BehavioursNode> behavioursNodes = layerBehaviourNodes[num];
					if (Object.op_Implicit((Object)(object)layer.StateMachine))
					{
						FillExistingStateMachineBehaviours("", layer.StateMachine, list, behavioursNodes, addedBehaviours);
						continue;
					}
					AssetTypeValueField layerField = val[num];
					FillSyncedStateMachineBehaviours(layer.NewSyncedBehaviours, stateMachineArray, behavioursNodes, layerField, list, addedBehaviours);
				}
				foreach (Layer newLayer in animatorModifications.NewLayers)
				{
					uint layerID = GetOrAddName(newLayer.Name);
					int num2 = ((IEnumerable<AssetTypeValueField>)val).IndexOf((AssetTypeValueField l) => l["data"]["m_Binding"].AsUInt == layerID);
					Dictionary<uint, BehavioursNode> behavioursNodes2 = layerBehaviourNodes[num2];
					if (Object.op_Implicit((Object)(object)newLayer.StateMachine))
					{
						FillStateMachineBehaviours("", newLayer.StateMachine, list, behavioursNodes2, addedBehaviours);
						continue;
					}
					AssetTypeValueField layerField2 = val[num2];
					FillSyncedStateMachineBehaviours(newLayer.SyncedBehaviours, stateMachineArray, behavioursNodes2, layerField2, list, addedBehaviours);
				}
			}
			currentModification = null;
			val2.Children.Clear();
			foreach (var item7 in list)
			{
				int item = item7.Item1;
				long item2 = item7.Item2;
				AssetTypeValueField val5 = ValueBuilder.DefaultValueFieldFromTemplate(val2.TemplateField.Children[1]);
				val2.Children.Add(val5);
				val5["m_FileID"].AsInt = item;
				val5["m_PathID"].AsLong = item2;
			}
			val4.Children.Clear();
			val3.Children.Clear();
			for (int k = 0; k < layerBehaviourNodes.Count; k++)
			{
				foreach (BehavioursNode value2 in layerBehaviourNodes[k].Values)
				{
					int count = val4.Children.Count;
					int num3 = 0;
					foreach (uint behaviour2 in value2.Behaviours)
					{
						num3++;
						AssetTypeValueField val6 = ValueBuilder.DefaultValueFieldFromTemplate(val4.TemplateField.Children[1]);
						val4.Children.Add(val6);
						val6.AsUInt = behaviour2;
					}
					if (value2.IsState)
					{
						for (BehavioursNode parent2 = value2.Parent; parent2 != null; parent2 = parent2.Parent)
						{
							for (int m = 0; m < parent2.Behaviours.Count; m++)
							{
								uint asUInt5 = parent2.Behaviours[m];
								num3++;
								AssetTypeValueField val7 = ValueBuilder.DefaultValueFieldFromTemplate(val4.TemplateField.Children[1]);
								val4.Children.Insert(count + m, val7);
								val7.AsUInt = asUInt5;
							}
						}
					}
					if (num3 > 0)
					{
						AssetTypeValueField val8 = ValueBuilder.DefaultValueFieldFromTemplate(val3.TemplateField.Children[1]);
						val3.Children.Add(val8);
						AssetTypeValueField obj5 = val8["first"];
						obj5["m_StateID"].AsUInt = value2.FullPathID;
						obj5["m_LayerIndex"].AsInt = k;
						AssetTypeValueField obj6 = val8["second"];
						obj6["m_StartIndex"].AsUInt = (uint)count;
						obj6["m_Count"].AsUInt = (uint)num3;
					}
				}
			}
			foreach (var item8 in list2)
			{
				int count2 = val4.Children.Count;
				int num4 = 0;
				foreach (uint item9 in item8.Item3)
				{
					num4++;
					AssetTypeValueField val9 = ValueBuilder.DefaultValueFieldFromTemplate(val4.TemplateField.Children[1]);
					val4.Children.Add(val9);
					val9.AsUInt = item9;
				}
				if (num4 > 0)
				{
					AssetTypeValueField val10 = ValueBuilder.DefaultValueFieldFromTemplate(val3.TemplateField.Children[1]);
					val3.Children.Add(val10);
					AssetTypeValueField obj7 = val10["first"];
					obj7["m_StateID"].AsUInt = item8.Item1;
					obj7["m_LayerIndex"].AsInt = item8.Item2;
					AssetTypeValueField obj8 = val10["second"];
					obj8["m_StartIndex"].AsUInt = (uint)count2;
					obj8["m_Count"].AsUInt = (uint)num4;
				}
			}
			val3.Children = (from f in val3.Children
				orderby f["first"]["m_StateID"].AsUInt, f["first"]["m_LayerIndex"].AsInt
				select f).ToList();
		}

		private void GatherLayerBehaviourNodes(AssetTypeValueField layerArray, AssetTypeValueField stateMachineArray, out List<Dictionary<uint, BehavioursNode>> layerBehaviourNodes)
		{
			layerBehaviourNodes = new List<Dictionary<uint, BehavioursNode>>();
			List<Dictionary<uint, BehavioursNode>> list = new List<Dictionary<uint, BehavioursNode>>();
			foreach (AssetTypeValueField item in stateMachineArray)
			{
				Dictionary<uint, BehavioursNode> dictionary = new Dictionary<uint, BehavioursNode>();
				list.Add(dictionary);
				foreach (AssetTypeValueField item2 in item["data"]["m_StateConstantArray"]["Array"])
				{
					uint asUInt = item2["data"]["m_FullPathID"].AsUInt;
					string fullPath2 = hashToName[asUInt];
					BehavioursNode value = new BehavioursNode
					{
						FullPathID = asUInt,
						FullPath = fullPath2,
						IsState = true,
						Parent = GetOrCreateParent(fullPath2, dictionary)
					};
					dictionary[asUInt] = value;
				}
			}
			foreach (AnimatorModifications modification in modifications)
			{
				AnimatorModifications animatorModifications = (currentModification = modification);
				foreach (ExistingLayer layer in animatorModifications.Layers)
				{
					if (Object.op_Implicit((Object)(object)layer.StateMachine))
					{
						uint layerID2 = GetOrAddName(layer.Name);
						uint asUInt2 = ((IEnumerable<AssetTypeValueField>)layerArray).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField l) => l["data"]["m_Binding"].AsUInt == layerID2))["data"]["m_StateMachineIndex"].AsUInt;
						Dictionary<uint, BehavioursNode> behavioursNodes2 = list[(int)asUInt2];
						FillBehaviourNodesFromExistingStateMachine(layer.StateMachine, behavioursNodes2, "");
					}
				}
				foreach (Layer newLayer in animatorModifications.NewLayers)
				{
					if (Object.op_Implicit((Object)(object)newLayer.StateMachine))
					{
						uint layerID = GetOrAddName(newLayer.Name);
						uint asUInt3 = ((IEnumerable<AssetTypeValueField>)layerArray).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField l) => l["data"]["m_Binding"].AsUInt == layerID))["data"]["m_StateMachineIndex"].AsUInt;
						Dictionary<uint, BehavioursNode> behavioursNodes3 = list[(int)asUInt3];
						FillBehaviourNodesFromStateMachine(newLayer.StateMachine, behavioursNodes3, "");
					}
				}
			}
			currentModification = null;
			foreach (AssetTypeValueField item3 in layerArray)
			{
				new Dictionary<uint, List<uint>>();
				uint asUInt4 = item3["data"]["m_StateMachineIndex"].AsUInt;
				uint asUInt5 = item3["data"]["m_StateMachineSynchronizedLayerIndex"].AsUInt;
				Dictionary<uint, BehavioursNode> dictionary2 = list[(int)asUInt4];
				if (asUInt5 != 0)
				{
					dictionary2 = dictionary2.ToDictionary((KeyValuePair<uint, BehavioursNode> n) => n.Key, (KeyValuePair<uint, BehavioursNode> n) => n.Value.IsState ? new BehavioursNode
					{
						FullPath = n.Value.FullPath,
						FullPathID = n.Value.FullPathID,
						Parent = n.Value.Parent,
						IsState = true
					} : n.Value);
				}
				layerBehaviourNodes.Add(dictionary2);
			}
			BehavioursNode GetOrCreateParent(string fullPath, Dictionary<uint, BehavioursNode> behavioursNodes)
			{
				int num = fullPath.LastIndexOf('.');
				if (num == -1)
				{
					return null;
				}
				string text = fullPath.Substring(0, num);
				uint orAddName = GetOrAddName(text);
				if (!behavioursNodes.TryGetValue(orAddName, out BehavioursNode value2))
				{
					value2 = (behavioursNodes[orAddName] = new BehavioursNode
					{
						FullPathID = orAddName,
						FullPath = text,
						IsState = false,
						Parent = GetOrCreateParent(text, behavioursNodes)
					});
				}
				return value2;
			}
		}

		private void FillBehaviourNodesFromExistingStateMachine(ExistingStateMachine stateMachine, Dictionary<uint, BehavioursNode> behavioursNodes, string stateMachinePath, BehavioursNode parent = null)
		{
			string text = (string.IsNullOrEmpty(stateMachinePath) ? stateMachine.Name : (stateMachinePath + "." + stateMachine.Name));
			uint orAddName = GetOrAddName(text);
			if (!behavioursNodes.TryGetValue(orAddName, out BehavioursNode value))
			{
				BehavioursNode obj = new BehavioursNode
				{
					FullPath = text,
					FullPathID = orAddName,
					Parent = parent,
					IsState = false
				};
				value = obj;
				behavioursNodes[orAddName] = obj;
			}
			foreach (ExistingStateMachine subStateMachine in stateMachine.SubStateMachines)
			{
				FillBehaviourNodesFromExistingStateMachine(subStateMachine, behavioursNodes, text, value);
			}
			foreach (StateMachine newSubStateMachine in stateMachine.NewSubStateMachines)
			{
				FillBehaviourNodesFromStateMachine(newSubStateMachine, behavioursNodes, text, value);
			}
		}

		private void FillBehaviourNodesFromStateMachine(StateMachine stateMachine, Dictionary<uint, BehavioursNode> behavioursNodes, string stateMachinePath, BehavioursNode parent = null)
		{
			string text = (string.IsNullOrEmpty(stateMachinePath) ? stateMachine.Name : (stateMachinePath + "." + stateMachine.Name));
			uint orAddName = GetOrAddName(text);
			if (!behavioursNodes.TryGetValue(orAddName, out BehavioursNode value))
			{
				BehavioursNode obj = new BehavioursNode
				{
					FullPath = text,
					FullPathID = orAddName,
					Parent = parent,
					IsState = false
				};
				value = obj;
				behavioursNodes[orAddName] = obj;
			}
			foreach (StateMachine subStateMachine in stateMachine.SubStateMachines)
			{
				FillBehaviourNodesFromStateMachine(subStateMachine, behavioursNodes, text, value);
			}
		}

		private void FillSyncedStateMachineBehaviours(List<SyncedBehaviour> syncedBehaviours, AssetTypeValueField stateMachineArray, Dictionary<uint, BehavioursNode> behavioursNodes, AssetTypeValueField layerField, List<(int, long)> behaviours, Dictionary<StateMachineBehaviour, uint> addedBehaviours)
		{
			uint asUInt = layerField["data"]["m_StateMachineIndex"].AsUInt;
			AssetTypeValueField obj = stateMachineArray[(int)asUInt];
			int asUInt2 = (int)obj["data"]["m_DefaultState"].AsUInt;
			uint asUInt3 = obj["data"]["m_StateConstantArray"]["Array"][asUInt2]["data"]["m_FullPathID"].AsUInt;
			BehavioursNode behavioursNode = behavioursNodes[asUInt3];
			while (behavioursNode.Parent != null)
			{
				behavioursNode = behavioursNode.Parent;
			}
			foreach (SyncedBehaviour syncedBehaviour in syncedBehaviours)
			{
				string text = (string.IsNullOrEmpty(syncedBehaviour.StateMachinePath) ? behavioursNode.FullPath : syncedBehaviour.StateMachinePath);
				uint orAddName = GetOrAddName(text + "." + syncedBehaviour.StateName);
				BehavioursNode behavioursNode2 = behavioursNodes[orAddName];
				foreach (StateMachineBehaviour behaviour in syncedBehaviour.Behaviours)
				{
					if (!addedBehaviours.TryGetValue(behaviour, out var value))
					{
						value = (uint)behaviours.Count;
						TryAddDependency((Object)(object)behaviour, out var fileID, out var pathID);
						behaviours.Add((fileID, pathID));
					}
					behavioursNode2.Behaviours.Add(value);
				}
			}
		}

		private void FillStateMachineBehaviours(string stateMachinePath, StateMachine stateMachine, List<(int, long)> behaviours, Dictionary<uint, BehavioursNode> behavioursNodes, Dictionary<StateMachineBehaviour, uint> addedBehaviours)
		{
			string text = (string.IsNullOrEmpty(stateMachinePath) ? stateMachine.Name : (stateMachinePath + "." + stateMachine.Name));
			uint orAddName = GetOrAddName(text);
			BehavioursNode behavioursNode = behavioursNodes[orAddName];
			foreach (StateMachineBehaviour behaviour in stateMachine.Behaviours)
			{
				if (!addedBehaviours.TryGetValue(behaviour, out var value))
				{
					value = (uint)behaviours.Count;
					if (!TryAddDependency((Object)(object)behaviour, out var fileID, out var pathID))
					{
						LogError("Behaviour for a StateMachine \"" + behavioursNode.FullPath + "\". Make sure it was loaded from an AssetBundle.");
						continue;
					}
					behaviours.Add((fileID, pathID));
				}
				behavioursNode.Behaviours.Add(value);
			}
			foreach (State state in stateMachine.States)
			{
				uint orAddName2 = GetOrAddName(text + "." + state.Name);
				BehavioursNode behavioursNode2 = behavioursNodes[orAddName2];
				foreach (StateMachineBehaviour behaviour2 in state.Behaviours)
				{
					if (!addedBehaviours.TryGetValue(behaviour2, out var value2))
					{
						value2 = (uint)behaviours.Count;
						if (!TryAddDependency((Object)(object)behaviour2, out var fileID2, out var pathID2))
						{
							LogError("Behaviour for a State \"" + behavioursNode2.FullPath + "\". Make sure it was loaded from an AssetBundle.");
							continue;
						}
						behaviours.Add((fileID2, pathID2));
					}
					behavioursNode2.Behaviours.Add(value2);
				}
			}
			foreach (StateMachine subStateMachine in stateMachine.SubStateMachines)
			{
				FillStateMachineBehaviours(text, subStateMachine, behaviours, behavioursNodes, addedBehaviours);
			}
		}

		private void FillExistingStateMachineBehaviours(string stateMachinePath, ExistingStateMachine stateMachine, List<(int, long)> behaviours, Dictionary<uint, BehavioursNode> behavioursNodes, Dictionary<StateMachineBehaviour, uint> addedBehaviours)
		{
			string text = (string.IsNullOrEmpty(stateMachinePath) ? stateMachine.Name : (stateMachinePath + "." + stateMachine.Name));
			uint orAddName = GetOrAddName(text);
			BehavioursNode behavioursNode = behavioursNodes[orAddName];
			foreach (StateMachineBehaviour newBehaviour in stateMachine.NewBehaviours)
			{
				if (!addedBehaviours.TryGetValue(newBehaviour, out var value))
				{
					value = (uint)behaviours.Count;
					if (!TryAddDependency((Object)(object)newBehaviour, out var fileID, out var pathID))
					{
						LogError("Behaviour for a StateMachine \"" + behavioursNode.FullPath + "\". Make sure it was loaded from an AssetBundle.");
						continue;
					}
					behaviours.Add((fileID, pathID));
				}
				behavioursNode.Behaviours.Add(value);
			}
			foreach (ExistingState state in stateMachine.States)
			{
				uint orAddName2 = GetOrAddName(text + "." + state.Name);
				BehavioursNode behavioursNode2 = behavioursNodes[orAddName2];
				foreach (StateMachineBehaviour newBehaviour2 in state.NewBehaviours)
				{
					if (!addedBehaviours.TryGetValue(newBehaviour2, out var value2))
					{
						value2 = (uint)behaviours.Count;
						if (!TryAddDependency((Object)(object)newBehaviour2, out var fileID2, out var pathID2))
						{
							LogError("Behaviour for a State \"" + behavioursNode2.FullPath + "\". Make sure it was loaded from an AssetBundle.");
							continue;
						}
						behaviours.Add((fileID2, pathID2));
					}
					behavioursNode2.Behaviours.Add(value2);
				}
			}
			foreach (State newState in stateMachine.NewStates)
			{
				uint orAddName3 = GetOrAddName(text + "." + newState.Name);
				BehavioursNode behavioursNode3 = behavioursNodes[orAddName3];
				foreach (StateMachineBehaviour behaviour in newState.Behaviours)
				{
					if (!addedBehaviours.TryGetValue(behaviour, out var value3))
					{
						value3 = (uint)behaviours.Count;
						if (!TryAddDependency((Object)(object)behaviour, out var fileID3, out var pathID3))
						{
							LogError("Behaviour for a State \"" + behavioursNode3.FullPath + "\". Make sure it was loaded from an AssetBundle.");
							continue;
						}
						behaviours.Add((fileID3, pathID3));
					}
					behavioursNode3.Behaviours.Add(value3);
				}
			}
			foreach (ExistingStateMachine subStateMachine in stateMachine.SubStateMachines)
			{
				FillExistingStateMachineBehaviours(text, subStateMachine, behaviours, behavioursNodes, addedBehaviours);
			}
			foreach (StateMachine newSubStateMachine in stateMachine.NewSubStateMachines)
			{
				FillStateMachineBehaviours(text, newSubStateMachine, behaviours, behavioursNodes, addedBehaviours);
			}
		}

		private void CreateBlendTreeFromMotion(AssetTypeValueField animationClips, IMotion motion, AssetTypeValueField blendTreeIndexArray, AssetTypeValueField blendTreeConstantArray)
		{
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(blendTreeIndexArray.TemplateField.Children[1]);
			blendTreeIndexArray.Children.Add(val);
			if (motion != null && (Object.op_Implicit((Object)(object)motion.Clip) || motion.BlendTree != null))
			{
				val.AsInt = blendTreeConstantArray.Children.Count;
				AssetTypeValueField val2 = ValueBuilder.DefaultValueFieldFromTemplate(blendTreeConstantArray.TemplateField.Children[1]);
				blendTreeConstantArray.Children.Add(val2);
				AssetTypeValueField nodeArray = val2["data"]["m_NodeArray"]["Array"];
				if (Object.op_Implicit((Object)(object)motion.Clip))
				{
					CreateBlendTreeNodeFromClip(animationClips, nodeArray, motion.Clip);
				}
				else
				{
					CreateBlendTreeNodeFromBlendTree(animationClips, nodeArray, motion.BlendTree);
				}
			}
			else
			{
				val.AsInt = -1;
			}
		}

		private int CreateBlendTreeNodeFromClip(AssetTypeValueField animationClips, AssetTypeValueField nodeArray, AnimationClip clip, float cycleOffset = 0f, bool mirror = false, float timeScale = 1f)
		{
			TryAddDependency((Object)(object)clip, out var fileID, out var pathID);
			int count = animationClips.Children.Count;
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(animationClips.TemplateField.Children[1]);
			val["m_FileID"].AsInt = fileID;
			val["m_PathID"].AsLong = pathID;
			animationClips.Children.Add(val);
			AssetTypeValueField val2 = ValueBuilder.DefaultValueFieldFromTemplate(nodeArray.TemplateField.Children[1]);
			AssetTypeValueField obj = val2["data"];
			obj["m_BlendEventID"].AsUInt = uint.MaxValue;
			obj["m_BlendEventYID"].AsUInt = uint.MaxValue;
			obj["m_ClipID"].AsInt = count;
			obj["m_Duration"].AsFloat = ((timeScale == 0f) ? 100f : (1f / timeScale));
			obj["m_CycleOffset"].AsFloat = cycleOffset;
			obj["m_Mirror"].AsBool = mirror;
			nodeArray.Children.Add(val2);
			return nodeArray.Children.Count - 1;
		}

		private int CreateBlendTreeNodeFromBlendTree(AssetTypeValueField animationClips, AssetTypeValueField nodeArray, IBlendTree blendTree, float cycleOffset = 0f, bool mirror = false)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected I4, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			//IL_009f: 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_00ad: Invalid comparison between Unknown and I4
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected I4, but got Unknown
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			uint orAddName = GetOrAddName(blendTree.BlendParameter);
			uint orAddName2 = GetOrAddName(blendTree.BlendParameterY);
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(nodeArray.TemplateField.Children[1]);
			nodeArray.Children.Add(val);
			int result = nodeArray.Children.Count - 1;
			AssetTypeValueField val2 = val["data"];
			val2["m_BlendType"].AsUInt = (uint)(int)blendTree.BlendType;
			if ((int)blendTree.BlendType != 4)
			{
				val2["m_BlendEventID"].AsUInt = orAddName;
			}
			else
			{
				val2["m_BlendEventID"].AsUInt = uint.MaxValue;
			}
			if ((int)blendTree.BlendType != 0 && (int)blendTree.BlendType != 4)
			{
				val2["m_BlendEventYID"].AsUInt = orAddName2;
			}
			else
			{
				val2["m_BlendEventYID"].AsUInt = uint.MaxValue;
			}
			val2["m_ClipID"].AsUInt = uint.MaxValue;
			val2["m_Duration"].AsFloat = 0f;
			val2["m_CycleOffset"].AsFloat = cycleOffset;
			val2["m_Mirror"].AsBool = mirror;
			AssetTypeValueField val3 = val2["m_ChildIndices"]["Array"];
			foreach (IChildMotion child in blendTree.Children)
			{
				if (Object.op_Implicit((Object)(object)((IMotion)child).Clip))
				{
					AssetTypeValueField val4 = ValueBuilder.DefaultValueFieldFromTemplate(val3.TemplateField.Children[1]);
					val4.AsInt = CreateBlendTreeNodeFromClip(animationClips, nodeArray, ((IMotion)child).Clip, child.CycleOffset, child.Mirror, child.TimeScale);
					val3.Children.Add(val4);
				}
				else if (((IMotion)child).BlendTree != null)
				{
					AssetTypeValueField val5 = ValueBuilder.DefaultValueFieldFromTemplate(val3.TemplateField.Children[1]);
					val5.AsInt = CreateBlendTreeNodeFromBlendTree(animationClips, nodeArray, ((IMotion)child).BlendTree, child.CycleOffset, child.Mirror);
					val3.Children.Add(val5);
				}
			}
			BlendTreeType blendType = blendTree.BlendType;
			switch ((int)blendType)
			{
			case 0:
			{
				AssetTypeValueField val10 = val2["m_Blend1dData"]["data"]["m_ChildThresholdArray"]["Array"];
				foreach (IChildMotion child2 in blendTree.Children)
				{
					AssetTypeValueField val11 = ValueBuilder.DefaultValueFieldFromTemplate(val10.TemplateField.Children[1]);
					val11.AsFloat = child2.Threshold;
					val10.Children.Add(val11);
				}
				break;
			}
			case 1:
			{
				AssetTypeValueField val8 = val2["m_Blend2dData"]["data"]["m_ChildPositionArray"]["Array"];
				foreach (IChildMotion child3 in blendTree.Children)
				{
					AssetTypeValueField val9 = ValueBuilder.DefaultValueFieldFromTemplate(val8.TemplateField.Children[1]);
					val9["x"].AsFloat = child3.Position.x;
					val9["y"].AsFloat = child3.Position.y;
					val8.Children.Add(val9);
				}
				break;
			}
			case 2:
			case 3:
				ComputeFreeform(blendTree, val2);
				break;
			case 4:
			{
				AssetTypeValueField val6 = val2["m_BlendDirectData"]["data"]["m_ChildBlendEventIDArray"]["Array"];
				foreach (IChildMotion child4 in blendTree.Children)
				{
					AssetTypeValueField val7 = ValueBuilder.DefaultValueFieldFromTemplate(val6.TemplateField.Children[1]);
					val7.AsUInt = GetOrAddName(child4.DirectBlendParameter);
					val6.Children.Add(val7);
				}
				break;
			}
			}
			return result;
		}

		private void ComputeFreeform(IBlendTree blendTree, AssetTypeValueField nodeDataField)
		{
			//IL_0050: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Invalid comparison between Unknown and I4
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Invalid comparison between Unknown and I4
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Invalid comparison between Unknown and I4
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Invalid comparison between Unknown and I4
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			int count = blendTree.Children.Count;
			Vector2[] array = (Vector2[])(object)new Vector2[count];
			float[] array2 = new float[count];
			Vector2[] array3 = (Vector2[])(object)new Vector2[count * count];
			float[] array4 = new float[count * count];
			bool[] array5 = new bool[count * count];
			Vector2 val2;
			for (int i = 0; i < blendTree.Children.Count; i++)
			{
				IChildMotion val = blendTree.Children[i];
				array[i] = val.Position;
				if ((int)blendTree.BlendType == 2)
				{
					int num = i;
					val2 = val.Position;
					array2[num] = ((Vector2)(ref val2)).magnitude;
				}
			}
			if ((int)blendTree.BlendType == 2)
			{
				for (int j = 0; j < count; j++)
				{
					IChildMotion val3 = blendTree.Children[j];
					for (int k = 0; k < count; k++)
					{
						IChildMotion val4 = blendTree.Children[k];
						int num2 = j + k * count;
						float num3 = array2[j];
						float num4 = array2[k];
						float num5 = num4 + num3;
						num5 = (array4[num2] = ((num5 == 0f) ? float.PositiveInfinity : (2f / num5)));
						float num6 = 0f;
						if (num4 != 0f && num3 != 0f)
						{
							num6 = Vector2.SignedAngle(val3.Position, val4.Position) * (MathF.PI / 180f);
						}
						float num7 = (num4 - num3) * num5;
						array3[num2] = new Vector2(num6, num7);
					}
				}
			}
			else if ((int)blendTree.BlendType == 3)
			{
				for (int l = 0; l < count; l++)
				{
					IChildMotion val5 = blendTree.Children[l];
					for (int m = 0; m < count; m++)
					{
						IChildMotion val6 = blendTree.Children[m];
						int num8 = l + m * count;
						val2 = val6.Position - val5.Position;
						array4[num8] = 1f / ((Vector2)(ref val2)).sqrMagnitude;
						Vector2 val7 = val6.Position - val5.Position;
						array3[num8] = val7;
					}
				}
			}
			ComputeNeighborsFreeform(blendTree, array, array2, array3, array4, array5);
			AssetTypeValueField obj = nodeDataField["m_Blend2dData"]["data"];
			AssetTypeValueField val8 = obj["m_ChildPositionArray"]["Array"];
			AssetTypeValueField val9 = obj["m_ChildMagnitudeArray"]["Array"];
			AssetTypeValueField val10 = obj["m_ChildPairVectorArray"]["Array"];
			AssetTypeValueField val11 = obj["m_ChildPairAvgMagInvArray"]["Array"];
			AssetTypeValueField val12 = obj["m_ChildNeighborListArray"]["Array"];
			for (int n = 0; n < array.Length; n++)
			{
				Vector2 val13 = array[n];
				AssetTypeValueField val14 = ValueBuilder.DefaultValueFieldFromTemplate(val8.TemplateField.Children[1]);
				val14["x"].AsFloat = val13.x;
				val14["y"].AsFloat = val13.y;
				val8.Children.Add(val14);
				if ((int)blendTree.BlendType == 2)
				{
					float asFloat = array2[n];
					AssetTypeValueField val15 = ValueBuilder.DefaultValueFieldFromTemplate(val9.TemplateField.Children[1]);
					val15.AsFloat = asFloat;
					val9.Children.Add(val15);
				}
				AssetTypeValueField val16 = ValueBuilder.DefaultValueFieldFromTemplate(val12.TemplateField.Children[1]);
				val12.Children.Add(val16);
				AssetTypeValueField val17 = val16["m_NeighborArray"]["Array"];
				for (int num9 = 0; num9 < count; num9++)
				{
					if (array5[n * count + num9])
					{
						AssetTypeValueField val18 = ValueBuilder.DefaultValueFieldFromTemplate(val17.TemplateField.Children[1]);
						val18.AsInt = num9;
						val17.Children.Add(val18);
					}
				}
			}
			for (int num10 = 0; num10 < array3.Length; num10++)
			{
				float asFloat2 = array4[num10];
				AssetTypeValueField val19 = ValueBuilder.DefaultValueFieldFromTemplate(val11.TemplateField.Children[1]);
				val19.AsFloat = asFloat2;
				val11.Children.Add(val19);
				Vector2 val20 = array3[num10];
				AssetTypeValueField val21 = ValueBuilder.DefaultValueFieldFromTemplate(val10.TemplateField.Children[1]);
				val21["x"].AsFloat = val20.x;
				val21["y"].AsFloat = val20.y;
				val10.Children.Add(val21);
			}
		}

		private void ComputeNeighborsFreeform(IBlendTree blendTree, Vector2[] positions, float[] magnitudes, Vector2[] pairVectors, float[] pairAvgMagInvs, bool[] neighbors)
		{
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Invalid comparison between Unknown and I4
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Invalid comparison between Unknown and I4
			int count = blendTree.Children.Count;
			int[] array = new int[count];
			Vector2[] workspaceBlendVectors = (Vector2[])(object)new Vector2[count];
			float num = 10000f;
			float num2 = -10000f;
			float num3 = 10000f;
			float num4 = -10000f;
			foreach (Vector2 val in positions)
			{
				num = Mathf.Min(num, val.x);
				num2 = Mathf.Max(num2, val.x);
				num3 = Mathf.Min(num3, val.y);
				num4 = Mathf.Max(num4, val.y);
			}
			float num5 = (num2 - num) * 0.5f;
			float num6 = (num4 - num3) * 0.5f;
			num -= num5;
			num2 += num5;
			num3 -= num6;
			num4 += num6;
			for (int j = 0; j <= 100; j++)
			{
				float num7 = (float)j * 0.01f;
				for (int k = 0; k <= 100; k++)
				{
					float num8 = (float)k * 0.01f;
					if ((int)blendTree.BlendType == 2)
					{
						GetWeightsFreeformDirectional(positions, magnitudes, pairVectors, pairAvgMagInvs, array, workspaceBlendVectors, num * (1f - num7) + num2 * num7, num3 * (1f - num8) + num4 * num8);
					}
					else if ((int)blendTree.BlendType == 3)
					{
						GetWeightsFreeformCartesian(positions, pairVectors, pairAvgMagInvs, array, workspaceBlendVectors, num * (1f - num7) + num2 * num7, num3 * (1f - num8) + num4 * num8);
					}
					for (int l = 0; l < count; l++)
					{
						if (array[l] >= 0)
						{
							neighbors[l * count + array[l]] = true;
						}
					}
				}
			}
		}

		private void GetWeightsFreeformCartesian(Vector2[] positions, Vector2[] pairVectors, float[] pairAvgMagInvs, int[] cropArray, Vector2[] workspaceBlendVectors, float blendValueX, float blendValueY)
		{
			//IL_0016: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int num = positions.Length;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(blendValueX, blendValueY);
			for (int i = 0; i < num; i++)
			{
				workspaceBlendVectors[i] = val - positions[i];
			}
			for (int j = 0; j < num; j++)
			{
				cropArray[j] = -1;
				Vector2 val2 = workspaceBlendVectors[j];
				float num2 = 1f;
				for (int k = 0; k < num; k++)
				{
					if (j != k)
					{
						int num3 = j + k * num;
						Vector2 val3 = pairVectors[num3];
						float num4 = 1f - Vector2.Dot(val3, val2) * pairAvgMagInvs[num3];
						if (num4 <= 0f)
						{
							cropArray[j] = -1;
							break;
						}
						if (num4 < num2)
						{
							cropArray[j] = k;
							num2 = num4;
						}
					}
				}
			}
		}

		private float GetWeightFreeformDirectional(Vector2[] positions, Vector2[] pairVectors, float[] pairAvgMagInvs, Vector2[] workspaceBlendVectors, int i, int j, Vector2 blendPosition)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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)
			int num = i + j * positions.Length;
			Vector2 val = pairVectors[num];
			Vector2 val2 = workspaceBlendVectors[i];
			val2.y *= pairAvgMagInvs[num];
			if (positions[i] == Vector2.zero)
			{
				val.x = workspaceBlendVectors[j].x;
			}
			else if (positions[j] == Vector2.zero)
			{
				val.x = workspaceBlendVectors[i].x;
			}
			else if (val.x == 0f || blendPosition == Vector2.zero)
			{
				val2.x = val.x;
			}
			return 1f - Vector2.Dot(val, val2) / ((Vector2)(ref val)).sqrMagnitude;
		}

		private void GetWeightsFreeformDirectional(Vector2[] positions, float[] magnitudes, Vector2[] pairVectors, float[] pairAvgMagInvs, int[] cropArray, Vector2[] workspaceBlendVectors, float blendValueX, float blendValueY)
		{
			//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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			int num = positions.Length;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(blendValueX, blendValueY);
			float magnitude = ((Vector2)(ref val)).magnitude;
			if (val == Vector2.zero)
			{
				for (int i = 0; i < num; i++)
				{
					workspaceBlendVectors[i] = new Vector2(0f, magnitude - magnitudes[i]);
				}
			}
			else
			{
				for (int j = 0; j < num; j++)
				{
					Vector2 val2 = positions[j];
					float num2 = 0f;
					if (val2 != Vector2.zero)
					{
						num2 = Vector2.SignedAngle(val2, val) * (MathF.PI / 180f);
					}
					workspaceBlendVectors[j] = new Vector2(num2, magnitude - magnitudes[j]);
				}
			}
			for (int k = 0; k < num; k++)
			{
				float num3 = 1f - Mathf.Abs(workspaceBlendVectors[k].x) * (1f / MathF.PI);
				cropArray[k] = -1;
				for (int l = 0; l < num; l++)
				{
					if (k != l)
					{
						float weightFreeformDirectional = GetWeightFreeformDirectional(positions, pairVectors, pairAvgMagInvs, workspaceBlendVectors, k, l, val);
						if (weightFreeformDirectional <= 0f)
						{
							cropArray[k] = -1;
							break;
						}
						if (weightFreeformDirectional < num3)
						{
							cropArray[k] = l;
							num3 = weightFreeformDirectional;
						}
					}
				}
			}
		}

		public ModificationsBundleCreator(AssetsManager manager, AssetsFileInstance assetFile, long sourceAnimatorControllerPathID, AssetsFileInstance dummyAssetFile, BundleFileInstance dummyBundleFile, long dummyAnimatorControllerPathID, List<AnimatorModifications> modifications, string modifiedBundlePath)
		{
			this.manager = manager;
			this.assetFile = assetFile;
			this.sourceAnimatorControllerPathID = sourceAnimatorControllerPathID;
			this.dummyAssetFile = dummyAssetFile;
			this.dummyBundleFile = dummyBundleFile;
			this.dummyAnimatorControllerPathID = dummyAnimatorControllerPathID;
			this.modifications = modifications;
			this.modifiedBundlePath = modifiedBundlePath;
		}

		public void Run()
		{
			//IL_0015: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			AssetExternal extAsset = manager.GetExtAsset(assetFile, 0, sourceAnimatorControllerPathID, false, (AssetReadFlags)0);
			baseField = extAsset.baseField;
			GatherNames();
			RemapPPtrs();
			AddLayers();
			AddStates();
			AddTransitions();
			foreach (Action delayedAction in delayedActions)
			{
				delayedAction();
			}
			AddBehaviours();
			AddParameters();
			AddTOS();
			SetExternals();
			SaveBundle();
		}

		private void GatherNames()
		{
			foreach (AssetTypeValueField item in baseField["m_TOS"]["Array"])
			{
				uint asUInt = item["first"].AsUInt;
				string asString = item["second"].AsString;
				hashToName[asUInt] = asString;
				nameToHash[asString] = asUInt;
			}
		}

		private void AddLayers()
		{
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected I4, but got Unknown
			AssetTypeValueField animationClips = baseField["m_AnimationClips"]["Array"];
			AssetTypeValueField val = baseField["m_Controller"];
			string asString = baseField["m_Name"].AsString;
			AssetTypeValueField val2 = val["m_LayerArray"]["Array"];
			AssetTypeValueField val3 = val["m_StateMachineArray"]["Array"];
			AssetTypeValueField val4 = baseField["m_StateMachineBehaviourVectorDescription"]["m_StateMachineBehaviourRanges"]["Array"];
			foreach (AnimatorModifications modification in modifications)
			{
				AnimatorModifications animatorModifications = (currentModification = modification);
				foreach (ExistingLayer layer in animatorModifications.Layers)
				{
					uint layerHash = GetOrAddName(layer.Name);
					AssetTypeValueField val5 = ((IEnumerable<AssetTypeValueField>)val["m_LayerArray"]["Array"]).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField f) => f["data"]["m_Binding"].AsUInt == layerHash));
					if (val5 == null)
					{
						LogError("Layer \"" + layer.Name + "\" not found for a controller \"" + asString + "\".");
					}
					else if (Object.op_Implicit((Object)(object)layer.StateMachine))
					{
						uint asUInt = val5["data"]["m_StateMachineIndex"].AsUInt;
						AssetTypeValueField stateMachineField = val3[(int)asUInt];
						ModifyStateMachine(animationClips, (IExistingStateMachine)(object)layer.StateMachine, stateMachineField, "");
					}
				}
				foreach (Layer item in animatorModifications.NewLayers.OrderBy((Layer l) => string.IsNullOrEmpty(l.SyncedLayerName)))
				{
					AssetTypeValueField val6 = ValueBuilder.DefaultValueFieldFromTemplate(val2.TemplateField.Children[1]);
					AssetTypeValueField val7 = val6["data"];
					CreateBodyMaskFromAvatarMask(val7["m_BodyMask"], item.AvatarMask);
					AssetTypeValueField skeletonMaskArrayField = val7["m_SkeletonMask"]["data"]["m_Data"]["Array"];
					CreateSkeletonMaskFromAvatarMask(skeletonMaskArrayField, item.AvatarMask);
					uint orAddName = GetOrAddName(item.Name);
					val7["m_Binding"].AsUInt = orAddName;
					val7["m_DefaultWeight"].AsFloat = item.DefaultWeight;
					val7["m_IKPass"].AsBool = item.IKPass;
					val7["m_SyncedLayerAffectsTiming"].AsBool = item.SyncedLayerAffectsTiming;
					val7["(int&)m_LayerBlendingMode"].AsInt = (int)item.BlendingMode;
					if (!string.IsNullOrEmpty(item.SyncedLayerName))
					{
						uint syncedLayerHash = GetOrAddName(item.SyncedLayerName);
						uint asUInt2 = ((IEnumerable<AssetTypeValueField>)val2).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField f) => f["data"]["m_Binding"].AsUInt == syncedLayerHash))["data"]["m_StateMachineIndex"].AsUInt;
						AssetTypeValueField obj = val3[(int)asUInt2];
						AssetTypeValueField val8 = obj["data"]["m_SynchronizedLayerCount"];
						val7["m_StateMachineIndex"].AsUInt = asUInt2;
						val7["m_StateMachineSynchronizedLayerIndex"].AsUInt = val8.AsUInt;
						uint asUInt3 = val8.AsUInt;
						val8.AsUInt = asUInt3 + 1;
						Dictionary<uint, SyncedMotion> dictionary = item.SyncedMotions.ToDictionary((SyncedMotion f) => GetOrAddName(f.StateMachinePath + "." + f.StateName));
						foreach (AssetTypeValueField item2 in obj["data"]["m_StateConstantArray"]["Array"])
						{
							AssetTypeValueField blendTreeIndexArray = item2["data"]["m_BlendTreeConstantIndexArray"]["Array"];
							AssetTypeValueField blendTreeConstantArray = item2["data"]["m_BlendTreeConstantArray"]["Array"];
							uint asUInt4 = item2["data"]["m_FullPathID"].AsUInt;
							SyncedMotion valueOrDefault = dictionary.GetValueOrDefault(asUInt4);
							CreateBlendTreeFromMotion(animationClips, (IMotion)(object)valueOrDefault, blendTreeIndexArray, blendTreeConstantArray);
						}
					}
					else
					{
						val7["m_StateMachineIndex"].AsUInt = CreateStateMachine((IStateMachine)(object)item.StateMachine, animationClips, val3);
						val7["m_StateMachineSynchronizedLayerIndex"].AsUInt = 0u;
					}
					int num = -1;
					if (!string.IsNullOrEmpty(item.PreviousLayerName))
					{
						uint previousLayerHash = GetOrAddName(item.PreviousLayerName);
						num = ((IEnumerable<AssetTypeValueField>)val2).IndexOf((AssetTypeValueField f) => f["data"]["m_Binding"].AsUInt == previousLayerHash);
					}
					foreach (AssetTypeValueField item3 in val4)
					{
						AssetTypeValueField val9 = item3["first"]["m_LayerIndex"];
						if (val9.AsInt > num)
						{
							int asInt = val9.AsInt;
							val9.AsInt = asInt + 1;
						}
					}
					val2.Children.Insert(num + 1, val6);
				}
			}
			currentModification = null;
		}

		private void ModifyStateMachine(AssetTypeValueField animationClips, IExistingStateMachine stateMachine, AssetTypeValueField stateMachineField, string stateMachinePath)
		{
			IExistingStateMachine stateMachine2 = stateMachine;
			uint asUInt = stateMachineField["data"]["m_SynchronizedLayerCount"].AsUInt;
			AssetTypeValueField statesArray = stateMachineField["data"]["m_StateConstantArray"]["Array"];
			AssetTypeValueField anyStateTransitionsArray = stateMachineField["data"]["m_AnyStateTransitionConstantArray"]["Array"];
			AssetTypeValueField selectorStatesArray = stateMachineField["data"]["m_SelectorStateConstantArray"]["Array"];
			string newStateMachinePath = (string.IsNullOrEmpty(stateMachinePath) ? stateMachine2.Name : (stateMachinePath + "." + stateMachine2.Name));
			delayedActions.Add(delegate
			{
				foreach (ISimpleTransition newEntryTransition in stateMachine2.NewEntryTransitions)
				{
					CreateSelectorTransition(newStateMachinePath, newEntryTransition, statesArray, selectorStatesArray);
				}
				foreach (ITransition newAnyStateTransition in stateMachine2.NewAnyStateTransitions)
				{
					CreateTransition(newStateMachinePath, "AnyState", newAnyStateTransition, anyStateTransitionsArray, statesArray, selectorStatesArray, "Entry");
				}
			});
			foreach (IExistingState state in stateMachine2.States)
			{
				ModifyState(newStateMachinePath, statesArray, selectorStatesArray, state);
			}
			foreach (IState newState in stateMachine2.NewStates)
			{
				CreateState(animationClips, newStateMachinePath, stateMachine2.Name, asUInt, statesArray, selectorStatesArray, newState);
			}
			foreach (IExistingStateMachine subStateMachine in stateMachine2.SubStateMachines)
			{
				ModifyStateMachine(animationClips, subStateMachine, stateMachineField, newStateMachinePath);
			}
			foreach (IStateMachine newSubStateMachine in stateMachine2.NewSubStateMachines)
			{
				CreateSubStateMachine(newStateMachinePath, newSubStateMachine, stateMachineField, animationClips);
			}
		}

		private void CreateSubStateMachine(string stateMachinePath, IStateMachine stateMachine, AssetTypeValueField stateMachineField, AssetTypeValueField animationClips)
		{
			IStateMachine stateMachine2 = stateMachine;
			string stateMachinePath2 = stateMachinePath;
			uint asUInt = stateMachineField["data"]["m_SynchronizedLayerCount"].AsUInt;
			AssetTypeValueField statesArray = stateMachineField["data"]["m_StateConstantArray"]["Array"];
			AssetTypeValueField anyStateTransitionsArray = stateMachineField["data"]["m_AnyStateTransitionConstantArray"]["Array"];
			AssetTypeValueField selectorStatesArray = stateMachineField["data"]["m_SelectorStateConstantArray"]["Array"];
			string newStateMachinePath = (string.IsNullOrEmpty(stateMachinePath2) ? stateMachine2.Name : (stateMachinePath2 + "." + stateMachine2.Name));
			uint orAddName = GetOrAddName(newStateMachinePath);
			CreateSelectorState(orAddName, selectorStatesArray, isEntry: true);
			AssetTypeValueField exitSelectorState = CreateSelectorState(orAddName, selectorStatesArray, isEntry: false);
			delayedActions.Add(delegate
			{
				//IL_0045: 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_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				if (string.IsNullOrEmpty(stateMachine2.Name) && string.IsNullOrEmpty(stateMachine2.DefaultStateMachinePath))
				{
					CreateSelectorTransition(uint.MaxValue, exitSelectorState);
				}
				else
				{
					CreateSelectorTransition(newStateMachinePath, (ISimpleTransition)new EntryTransition
					{
						DestinationStateName = stateMachine2.DefaultStateName,
						DestinationStateMachinePath = stateMachine2.DefaultStateMachinePath
					}, statesArray, selectorStatesArray);
				}
				if (string.IsNullOrEmpty(stateMachinePath2))
				{
					CreateSelectorTransition(30000u, exitSelectorState);
				}
				else
				{
					uint orAddName2 = GetOrAddName(stateMachinePath2);
					uint destinationState = 30000u;
					for (int i = 0; i < selectorStatesArray.Children.Count; i++)
					{
						AssetTypeValueField val = selectorStatesArray[i]["data"];
						if (val["m_FullPathID"].AsUInt == orAddName2 && val["m_IsEntry"].AsBool)
						{
							destinationState = val["m_TransitionConstantArray"]["Array"][0]["data"]["m_Destination"].AsUInt;
							break;
						}
					}
					CreateSelectorTransition(destinationState, exitSelectorState);
				}
				foreach (ISimpleTransition entryTransition in stateMachine2.EntryTransitions)
				{
					CreateSelectorTransition(newStateMachinePath, entryTransition, statesArray, selectorStatesArray);
				}
				foreach (ITransition anyStateTransition in stateMachine2.AnyStateTransitions)
				{
					CreateTransition(newStateMachinePath, "AnyState", anyStateTransition, anyStateTransitionsArray, statesArray, selectorStatesArray, "Entry");
				}
			});
			foreach (IState state in stateMachine2.States)
			{
				CreateState(animationClips, newStateMachinePath, stateMachine2.Name, asUInt, statesArray, selectorStatesArray, state);
			}
			foreach (IStateMachine subStateMachine in stateMachine2.SubStateMachines)
			{
				CreateSubStateMachine(newStateMachinePath, subStateMachine, stateMachineField, selectorStatesArray);
			}
		}

		private AssetTypeValueField CreateSelectorState(uint stateMachinePathHash, AssetTypeValueField selectorStatesArray, bool isEntry)
		{
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(selectorStatesArray.TemplateField.Children[1]);
			selectorStatesArray.Children.Add(val);
			AssetTypeValueField obj = val["data"];
			obj["m_FullPathID"].AsUInt = stateMachinePathHash;
			obj["m_IsEntry"].AsBool = isEntry;
			return val;
		}

		private void CreateSelectorTransition(string stateMachinePath, ISimpleTransition entryTransition, AssetTypeValueField statesArray, AssetTypeValueField selectorStatesArray)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected I4, but got Unknown
			string text = (string.IsNullOrEmpty(entryTransition.DestinationStateMachinePath) ? stateMachinePath : entryTransition.DestinationStateMachinePath) + "." + entryTransition.DestinationStateName;
			uint orAddName = GetOrAddName(text);
			uint transitionFullPathHash = GetOrAddName(stateMachinePath);
			uint transitionDestinationState = GetTransitionDestinationState(entryTransition.DestinationStateName, statesArray, selectorStatesArray, orAddName);
			if (transitionDestinationState == uint.MaxValue)
			{
				LogError("Destination state by path \"" + text + "\" was not found.");
				return;
			}
			AssetTypeValueField val = ((IEnumerable<AssetTypeValueField>)selectorStatesArray).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField s) => s["data"]["m_FullPathID"].AsUInt == transitionFullPathHash && s["data"]["m_IsEntry"].AsBool));
			if (val == null)
			{
				LogError("StateMachine \"" + stateMachinePath + "\" was not found.");
				return;
			}
			AssetTypeValueField val2 = CreateSelectorTransition(transitionDestinationState, val)["data"]["m_ConditionConstantArray"]["Array"];
			foreach (ICondition condition in entryTransition.Conditions)
			{
				uint orAddName2 = GetOrAddName(condition.ParamName);
				AssetTypeValueField val3 = ValueBuilder.DefaultValueFieldFromTemplate(val2.TemplateField.Children[1]);
				AssetTypeValueField obj = val3["data"];
				obj["m_ConditionMode"].AsUInt = (uint)(int)condition.ConditionMode;
				obj["m_EventID"].AsUInt = orAddName2;
				obj["m_EventThreshold"].AsFloat = condition.Value;
				obj["m_ExitTime"].AsFloat = 0f;
				val2.Children.Add(val3);
			}
		}

		private AssetTypeValueField CreateSelectorTransition(uint destinationState, AssetTypeValueField selectorState)
		{
			AssetTypeValueField obj = selectorState["data"]["m_TransitionConstantArray"]["Array"];
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(obj.TemplateField.Children[1]);
			val["data"]["m_Destination"].AsUInt = destinationState;
			obj.Children.Add(val);
			return val;
		}

		private void ModifyState(string stateMachinePath, AssetTypeValueField statesArray, AssetTypeValueField selectorStatesArray, IExistingState state)
		{
			IExistingState state2 = state;
			string stateMachinePath2 = stateMachinePath;
			AssetTypeValueField statesArray2 = statesArray;
			AssetTypeValueField selectorStatesArray2 = selectorStatesArray;
			string text = stateMachinePath2 + "." + state2.Name;
			uint fullPathID = GetOrAddName(text);
			AssetTypeValueField stateField = ((IEnumerable<AssetTypeValueField>)statesArray2).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField s) => s["data"]["m_FullPathID"].AsUInt == fullPathID));
			if (stateField == null)
			{
				LogError("State \"" + text + "\" was not found.");
				return;
			}
			delayedActions.Add(delegate
			{
				AssetTypeValueField transitions = stateField["data"]["m_TransitionConstantArray"]["Array"];
				foreach (ITransition newTransition in state2.NewTransitions)
				{
					CreateTransition(stateMachinePath2, state2.Name, newTransition, transitions, statesArray2, selectorStatesArray2);
				}
			});
		}

		private uint CreateStateMachine(IStateMachine stateMachine, AssetTypeValueField animationClips, AssetTypeValueField stateMachineArray)
		{
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(stateMachineArray.TemplateField.Children[1]);
			int count = stateMachineArray.Children.Count;
			stateMachineArray.Children.Add(val);
			AssetTypeValueField val2 = val["data"];
			AssetTypeValueField states = val2["m_StateConstantArray"]["Array"];
			AssetTypeValueField selectorStates = val2["m_SelectorStateConstantArray"]["Array"];
			val2["m_SynchronizedLayerCount"].AsUInt = 1u;
			CreateSubStateMachine("", stateMachine, val, animationClips);
			if (string.IsNullOrEmpty(stateMachine.DefaultStateName))
			{
				string name = (string.IsNullOrEmpty(stateMachine.DefaultStateMachinePath) ? stateMachine.Name : stateMachine.DefaultStateMachinePath);
				val2["m_DefaultState"].AsUInt = GetTransitionDestinationState(stateMachine.DefaultStateName, states, selectorStates, GetOrAddName(name));
				return (uint)count;
			}
			val2["m_DefaultState"].AsUInt = 0u;
			return (uint)count;
		}

		private void CreateSkeletonMaskFromAvatarMask(AssetTypeValueField skeletonMaskArrayField, AvatarMask avatarMask)
		{
			if (Object.op_Implicit((Object)(object)avatarMask))
			{
				int transformCount = avatarMask.transformCount;
				for (int i = 0; i < transformCount; i++)
				{
					AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(skeletonMaskArrayField.TemplateField.Children[1]);
					skeletonMaskArrayField.Children.Add(val);
					val["m_PathHash"].AsUInt = GetOrAddName(avatarMask.GetTransformPath(i));
					val["m_Weight"].AsFloat = avatarMask.GetTransformWeight(i);
				}
			}
		}

		private void CreateBodyMaskFromAvatarMask(AssetTypeValueField bodyMask, AvatarMask avatarMask)
		{
			uint num = 0u;
			uint num2 = 0u;
			uint num3 = 0u;
			if (Object.op_Implicit((Object)(object)avatarMask))
			{
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)0))
				{
					num |= 1u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)1))
				{
					num |= 0x3FEu;
					num2 |= 0xC0000000u;
					num3 |= 1u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)2))
				{
					num |= 0x3FFC00u;
					num3 |= 6u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)3))
				{
					num |= 0x3FC00000u;
					num3 |= 0x78u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)4))
				{
					num |= 0xC0000000u;
					num2 |= 0x3Fu;
					num3 |= 0x780u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)5))
				{
					num2 |= 0x7FC0u;
					num3 |= 0x7800u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)6))
				{
					num2 |= 0xFF8000u;
					num3 |= 0x78000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)7))
				{
					num2 |= 0x10000000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)8))
				{
					num2 |= 0x20000000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)9))
				{
					num2 |= 0x1000000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)10))
				{
					num2 |= 0x2000000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)11))
				{
					num2 |= 0x4000000u;
				}
				if (avatarMask.GetHumanoidBodyPartActive((AvatarMaskBodyPart)12))
				{
					num2 |= 0x8000000u;
				}
			}
			else
			{
				num = uint.MaxValue;
				num2 = uint.MaxValue;
				num3 = 524287u;
			}
			bodyMask["word0"].Value.AsUInt = num;
			bodyMask["word1"].Value.AsUInt = num2;
			bodyMask["word2"].Value.AsUInt = num3;
		}

		private void AddParameters()
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected I4, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Invalid comparison between Unknown and I4
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Expected I4, but got Unknown
			HashSet<uint> hashSet = new HashSet<uint>();
			AssetTypeValueField obj = baseField["m_Controller"];
			AssetTypeValueField val = obj["m_Values"]["data"]["m_ValueArray"]["Array"];
			AssetTypeValueField obj2 = obj["m_DefaultValues"]["data"];
			AssetTypeValueField val2 = obj2["m_BoolValues"]["Array"];
			AssetTypeValueField val3 = obj2["m_FloatValues"]["Array"];
			AssetTypeValueField val4 = obj2["m_IntValues"]["Array"];
			foreach (AssetTypeValueField item in val)
			{
				hashSet.Add(item["m_ID"].AsUInt);
			}
			foreach (AnimatorModifications modification in modifications)
			{
				foreach (Parameter newParameter in (currentModification = modification).NewParameters)
				{
					uint orAddName = GetOrAddName(newParameter.Name);
					if (!hashSet.Add(orAddName))
					{
						LogError("Parameter " + newParameter.Name + " already exists for " + baseField["m_Name"].AsString + ".");
						continue;
					}
					ParameterType type = newParameter.Type;
					int count;
					switch (type - 1)
					{
					default:
						if ((int)type == 9)
						{
							goto case 3;
						}
						goto case 1;
					case 0:
					{
						count = val3.Children.Count;
						AssetTypeValueField val6 = ValueBuilder.DefaultValueFieldFromTemplate(val3.TemplateField.Children[1]);
						val6.AsFloat = ParameterValue.op_Implicit(newParameter.Value);
						val3.Children.Add(val6);
						break;
					}
					case 2:
					{
						count = val4.Children.Count;
						AssetTypeValueField val5 = ValueBuilder.DefaultValueFieldFromTemplate(val4.TemplateField.Children[1]);
						val5.AsInt = ParameterValue.op_Implicit(newParameter.Value);
						val4.Children.Add(val5);
						break;
					}
					case 3:
					{
						count = val2.Children.Count;
						AssetTypeValueField val7 = ValueBuilder.DefaultValueFieldFromTemplate(val2.TemplateField.Children[1]);
						val7.AsBool = ParameterValue.op_Implicit(newParameter.Value);
						val2.Children.Add(val7);
						break;
					}
					case 1:
						LogError($"Not supported parameter type {newParameter.Type} for parameter \"{newParameter.Name}\".");
						continue;
					}
					AssetTypeValueField val8 = ValueBuilder.DefaultValueFieldFromTemplate(val.TemplateField.Children[1]);
					val8["m_ID"].AsUInt = orAddName;
					val8["m_Type"].AsUInt = (uint)(int)newParameter.Type;
					val8["m_Index"].AsUInt = (uint)count;
					val.Children.Add(val8);
				}
			}
			currentModification = null;
		}

		private void AddStates()
		{
			AssetTypeValueField animationClips = baseField["m_AnimationClips"]["Array"];
			AssetTypeValueField val = baseField["m_Controller"];
			string asString = baseField["m_Name"].AsString;
			foreach (AnimatorModifications modification in modifications)
			{
				foreach (KeyValuePair<string, List<State>> newState in (currentModification = modification).NewStates)
				{
					newState.Deconstruct(out var key, out var value);
					string text = key;
					List<State> list = value;
					uint layerHash = GetOrAddName(text);
					AssetTypeValueField val2 = ((IEnumerable<AssetTypeValueField>)val["m_LayerArray"]["Array"]).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField f) => f["data"]["m_Binding"].AsUInt == layerHash));
					if (val2 == null)
					{
						LogError("Layer \"" + text + "\" not found for a controller \"" + asString + "\".");
						continue;
					}
					uint asUInt = val2["data"]["m_StateMachineIndex"].AsUInt;
					AssetTypeValueField obj = val["m_StateMachineArray"]["Array"][(int)asUInt];
					uint asUInt2 = obj["data"]["m_SynchronizedLayerCount"].AsUInt;
					AssetTypeValueField statesArray = obj["data"]["m_StateConstantArray"]["Array"];
					AssetTypeValueField selectorStatesArray = obj["data"]["m_SelectorStateConstantArray"]["Array"];
					foreach (State item in list)
					{
						CreateState(animationClips, text, text, asUInt2, statesArray, selectorStatesArray, (IState)(object)item);
					}
				}
			}
			currentModification = null;
		}

		private void CreateState(AssetTypeValueField animationClips, string stateMachinePath, string stateMachineName, uint synchronizedLayerCount, AssetTypeValueField statesArray, AssetTypeValueField selectorStatesArray, IState state)
		{
			IState state2 = state;
			string stateMachinePath2 = stateMachinePath;
			AssetTypeValueField statesArray2 = statesArray;
			AssetTypeValueField selectorStatesArray2 = selectorStatesArray;
			uint orAddName = GetOrAddName(state2.Name);
			string name = stateMachineName + "." + state2.Name;
			uint orAddName2 = GetOrAddName(name);
			string name2 = stateMachinePath2 + "." + state2.Name;
			uint orAddName3 = GetOrAddName(name2);
			uint orAddName4 = GetOrAddName(state2.Tag);
			uint orAddName5 = GetOrAddName(state2.SpeedParam);
			uint orAddName6 = GetOrAddName(state2.MirrorParam);
			uint orAddName7 = GetOrAddName(state2.CycleOffsetParam);
			uint orAddName8 = GetOrAddName(state2.TimeParam);
			AssetTypeValueField stateField = ValueBuilder.DefaultValueFieldFromTemplate(statesArray2.TemplateField.Children[1]);
			AssetTypeValueField obj = stateField["data"];
			obj["m_NameID"].AsUInt = orAddName;
			obj["m_PathID"].AsUInt = orAddName2;
			obj["m_FullPathID"].AsUInt = orAddName3;
			obj["m_TagID"].AsUInt = orAddName4;
			obj["m_SpeedParamID"].AsUInt = orAddName5;
			obj["m_MirrorParamID"].AsUInt = orAddName6;
			obj["m_CycleOffsetParamID"].AsUInt = orAddName7;
			obj["m_TimeParamID"].AsUInt = orAddName8;
			obj["m_Speed"].AsFloat = state2.Speed;
			obj["m_CycleOffset"].AsFloat = state2.CycleOffset;
			obj["m_IKOnFeet"].AsBool = state2.IKOnFeet;
			obj["m_WriteDefaultValues"].AsBool = state2.WriteDefaultValues;
			obj["m_Loop"].AsBool = state2.Loop;
			obj["m_Mirror"].AsBool = state2.Mirror;
			statesArray2.Children.Add(stateField);
			delayedActions.Add(delegate
			{
				AssetTypeValueField transitions = stateField["data"]["m_TransitionConstantArray"]["Array"];
				foreach (ITransition transition in state2.Transitions)
				{
					CreateTransition(stateMachinePath2, state2.Name, transition, transitions, statesArray2, selectorStatesArray2);
				}
			});
			AssetTypeValueField blendTreeIndexArray = stateField["data"]["m_BlendTreeConstantIndexArray"]["Array"];
			AssetTypeValueField blendTreeConstantArray = stateField["data"]["m_BlendTreeConstantArray"]["Array"];
			CreateBlendTreeFromMotion(animationClips, (IMotion)(object)state2, blendTreeIndexArray, blendTreeConstantArray);
			for (int i = 1; i < synchronizedLayerCount; i++)
			{
				CreateBlendTreeFromMotion(animationClips, null, blendTreeIndexArray, blendTreeConstantArray);
			}
		}

		private bool TryAddDependency(Object obj, out int fileID, out long pathID)
		{
			pathID = NativeHelpers.GetAssetPathID(obj);
			fileID = 0;
			if (pathID == 0L)
			{
				return false;
			}
			string pathName = NativeHelpers.GetPathName(obj);
			if (string.IsNullOrEmpty(pathName))
			{
				return false;
			}
			fileID = dependencies.IndexOf(pathName);
			if (fileID == -1)
			{
				fileID = dependencies.Count;
				dependencies.Add(pathName);
			}
			fileID++;
			return true;
		}

		private void AddTransitions()
		{
			AssetTypeValueField val = baseField["m_Controller"];
			string asString = baseField["m_Name"].AsString;
			foreach (AnimatorModifications modification in modifications)
			{
				foreach (KeyValuePair<(string, string), List<Transition>> newTransition in (currentModification = modification).NewTransitions)
				{
					newTransition.Deconstruct(out var key, out var value);
					(string, string) tuple = key;
					string layerName = tuple.Item1;
					string stateName = tuple.Item2;
					List<Transition> transitions = value;
					uint layerHash = GetOrAddName(layerName);
					uint stateHash = GetOrAddName(stateName);
					AssetTypeValueField val2 = ((IEnumerable<AssetTypeValueField>)val["m_LayerArray"]["Array"]).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField f) => f["data"]["m_Binding"].AsUInt == layerHash));
					if (val2 == null)
					{
						LogError("Layer \"" + layerName + "\" not found for controller " + asString + ".");
						continue;
					}
					uint asUInt = val2["data"]["m_StateMachineIndex"].AsUInt;
					AssetTypeValueField val3 = val["m_StateMachineArray"]["Array"][(int)asUInt];
					AssetTypeValueField states = val3["data"]["m_StateConstantArray"]["Array"];
					AssetTypeValueField selectorStates = val3["data"]["m_SelectorStateConstantArray"]["Array"];
					AssetTypeValueField stateField = ((IEnumerable<AssetTypeValueField>)states).FirstOrDefault((Func<AssetTypeValueField, bool>)((AssetTypeValueField f) => f["data"]["m_NameID"].AsUInt == stateHash));
					if (stateField == null)
					{
						LogError("State \"" + stateName + "\" not found for a layer \"" + layerName + "\" for a controller \"" + asString + "\".");
						continue;
					}
					delayedActions.Add(delegate
					{
						AssetTypeValueField transitions2 = stateField["data"]["m_TransitionConstantArray"]["Array"];
						foreach (Transition item in transitions)
						{
							CreateTransition(layerName, stateName, (ITransition)(object)item, transitions2, states, selectorStates);
						}
					});
				}
			}
			currentModification = null;
		}

		private void CreateTransition(string stateMachinePath, string stateName, ITransition transition, AssetTypeValueField transitions, AssetTypeValueField states, AssetTypeValueField selectorStates, string fullPathOverride = null)
		{
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected I4, but got Unknown
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Expected I4, but got Unknown
			string text = fullPathOverride ?? (stateMachinePath + "." + stateName);
			string text2 = (string.IsNullOrEmpty(((ISimpleTransition)transition).DestinationStateMachinePath) ? stateMachinePath : ((ISimpleTransition)transition).DestinationStateMachinePath);
			string text3 = ((ISimpleTransition)transition).DestinationStateName;
			if (string.IsNullOrEmpty(text3))
			{
				int num = text2.LastIndexOf('.');
				if (num == -1)
				{
					text3 = text2;
				}
				else
				{
					string text4 = text2;
					int num2 = num + 1;
					text3 = text4.Substring(num2, text4.Length - num2);
				}
			}
			string text5 = (string.IsNullOrEmpty(((ISimpleTransition)transition).DestinationStateName) ? text2 : (text2 + "." + ((ISimpleTransition)transition).DestinationStateName));
			uint orAddName = GetOrAddName(text5);
			uint transitionDestinationState = GetTransitionDestinationState(((ISimpleTransition)transition).DestinationStateName, states, selectorStates, orAddName, transition.IsExit);
			if (transitionDestinationState == uint.MaxValue)
			{
				LogError("Destination state by path \"" + text5 + "\" was not found.");
				return;
			}
			string name = stateName + " -> " + (transition.IsExit ? "Exit" : text3);
			uint orAddName2 = GetOrAddName(name);
			string name2 = text + " -> " + ((transitionDestinationState >= 30000) ? "Exit" : text5);
			uint orAddName3 = GetOrAddName(name2);
			AssetTypeValueField val = ValueBuilder.DefaultValueFieldFromTemplate(transitions.TemplateField.Children[1]);
			AssetTypeValueField obj = val["data"];
			obj["m_DestinationState"].AsUInt = transitionDestinationState;
			obj["m_FullPathID"].AsUInt = orAddName3;
			obj["m_ID"].AsUInt = orAddName2;
			obj["m_UserID"].AsUInt = 0u;
			obj["m_TransitionOffset"].AsFloat = transition.Offset;
			obj["m_TransitionDuration"].AsFloat = transition.TransitionDuration;
			obj["m_HasFixedDuration"].AsBool = transition.HasFixedDuration;
			obj["m_HasExitTime"].AsBool = transition.HasExitTime;
			obj["m_ExitTime"].AsFloat = transition.ExitTime;
			obj["m_InterruptionSource"].AsInt = (int)transition.InterruptionSource;
			obj["m_CanTransitionToSelf"].AsBool = transition.CanTransitionToSelf;
			obj["m_OrderedInterruption"].AsBool = transition.OrderedInterruption;
			transitions.Children.Add(val);
			AssetTypeValueField val2 = obj["m_ConditionConstantArray"]["Array"];
			foreach (ICondition condition in ((ISimpleTransition)transition).Conditions)
			{
				uint orAddName4 = GetOrAddName(condition.ParamName);
				AssetTypeValueField val3 = ValueBuilder.DefaultValueFieldFromTemplate(val2.TemplateField.Children[1]);
				AssetTypeValueField obj2 = val3["data"];
				obj2["m_ConditionMode"].AsUInt = (uint)(int)condition.ConditionMode;
				obj2["m_EventID"].AsUInt = orAddName4;
				obj2["m_EventThreshold"].AsFloat = condition.Value;
				obj2["m_ExitTime"].AsFloat = 0f;
				val2.Children.Add(val3);
			}
		}

		private static uint GetTransitionDestinationState(string stateName, AssetTypeValueField states, AssetTypeValueField selectorStates, uint stateFullPathHash, bool isExit = false)
		{
			if (string.IsNullOrEmpty(stateName))
			{
				for (int i = 0; i < selectorStates.Children.Count; i++)
				{
					AssetTypeValueField val = selectorStates[i]["data"];
					if (val["m_FullPathID"].AsUInt == stateFullPathHash && val["m_IsEntry"].AsBool != isExit)
					{
						return (uint)(i + 30000);
					}
				}
			}
			else
			{
				for (int j = 0; j < states.Children.Count; j++)
				{
					if (states[j]["data"]["m_FullPathID"].AsUInt == stateFullPathHash)
					{
						return (uint)j;
					}
				}
			}
			return uint.MaxValue;
		}

		private void AddTOS()
		{
			AssetTypeValueField val = baseField["m_TOS"]["Array"];
			foreach (string newName in newNames)
			{
				uint asUInt = nameToHash[newName];
				AssetTypeValueField val2 = ValueBuilder.DefaultValueFieldFromTemplate(val.TemplateField.Children[1]);
				val2["first"].AsUInt = asUInt;
				val2["second"].AsString = newName;
				val.Children.Add(val2);
			}
		}

		private void SaveBundle()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			AssetExternal extAsset = manager.GetExtAsset(dummyAssetFile, 0, dummyAnimatorControllerPathID, false, (AssetReadFlags)0);
			baseField["m_Name"].AsString = baseField["m_Name"].AsString + " (Modified)";
			extAsset.info.SetNewData(baseField);
			AssetBundleDirectoryInfo val = dummyBundleFile.file.BlockAndDirInfo.DirectoryInfos[0];
			val.SetNewData(dummyAssetFile.file);
			val.Name = Path.GetFileNameWithoutExtension(modifiedBundlePath);
			AssetExternal extAsset2 = manager.GetExtAsset(dummyAssetFile, 0, 1L, false, (AssetReadFlags)0);
			AssetTypeValueField val2 = extAsset2.baseField;
			val2["m_Name"].AsString = val.Name;
			extAsset2.info.SetNewData(val2);
			Directory.CreateDirectory(Path.GetDirectoryName(modifiedBundlePath));
			using FileStream fileStream = File.Open(modifiedBundlePath, FileMode.Create, FileAccess.Write);
			AssetsFileWriter val3 = new AssetsFileWriter(fileStream);
			try
			{
				dummyBundleFile.file.Write(val3, 0L);
			}
			finally
			{
				((IDisposable)val3)?.Dispose();
			}
		}

		private void SetExternals()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			List<AssetsFileExternal> externals = dummyAssetFile.file.Metadata.Externals;
			foreach (string dependency in dependencies)
			{
				externals.Add(new AssetsFileExternal
				{
					PathName = dependency,
					Type = (AssetsFileExternalType)0,
					VirtualAssetPathName = ""
				});
			}
		}

		private void RemapPPtrs()
		{
			List<AssetTypeValueField> list = new List<AssetTypeValueField>();
			GatherPPtrFileIDFields(baseField, list);
			HashSet<int> hashSet = new HashSet<int>();
			foreach (AssetTypeValueField item2 in list)
			{
				hashSet.Add(item2.AsInt);
			}
			int num = 1;
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			foreach (int item3 in hashSet.OrderBy((int d) => d))
			{
				dictionary[item3] = num++;
				if (item3 == 0)
				{
					string item = "archive:/" + assetFile.name + "/" + assetFile.name;
					dependencies.Add(item);
				}
				else
				{
					dependencies.Add(assetFile.file.Metadata.Externals[item3 - 1].PathName);
				}
			}
			foreach (AssetTypeValueField item4 in list)
			{
				item4.AsInt = dictionary[item4.AsInt];
			}
		}

		private void GatherPPtrFileIDFields(AssetTypeValueField field, List<AssetTypeValueField> fields)
		{
			if (field.TypeName.StartsWith("PPtr<"))
			{
				AssetTypeValueField item = field["m_FileID"];
				fields.Add(item);
				return;
			}
			foreach (AssetTypeValueField child in field.Children)
			{
				GatherPPtrFileIDFields(child, fields);
			}
		}

		private uint GetOrAddName(string name)
		{
			if (name == null)
			{
				return 0u;
			}
			if (nameToHash.TryGetValue(name, out var value))
			{
				return value;
			}
			value = (uint)Animator.StringToHash(name);
			newNames.Add(name);
			hashToName[value] = name;
			nameToHash[name] = value;
			return value;
		}

		private void LogError(string message)
		{
			if (currentModification != null)
			{
				AnimationsPlugin.Logger.LogError((object)(message + " | Mod: " + currentModification.Key));
			}
			else
			{
				AnimationsPlugin.Logger.LogError((object)message);
			}
		}
	}
	internal static class NativeHelpers
	{
		[UnmanagedFunctionPointer(CallingConvention.ThisCall)]
		private unsafe delegate void InstanceIDToSerializedObjectIdentifierHandler(IntPtr remapper, int instanceID, SerializedObjectIdentifier* identifier);

		[UnmanagedFunctionPointer(CallingConvention.ThisCall)]
		private unsafe delegate IntPtr PersistentManagerGetPathNameHandler(PersistentManager* persistentManager, StringStorageDefaultV2* returnString, int instanceID);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void FreeAllocInternalHandler(IntPtr ptr, int label, IntPtr file, int line);

		private const int InstanceIDToSerializedObjectIdentifierOffset = 6881312;

		private const int PersistentManagerGetPathNameOffset = 6809328;

		private const int FreeAllocInternalOffset = 2593600;

		private const int PersistentManagerOffset = 28557672;

		private static IntPtr PersistentManagerPtr;

		private static InstanceIDToSerializedObjectIdentifierHandler InstanceIDToSerializedObjectIdentifier;

		private static PersistentManagerGetPathNameHandler PersistentManagerGetPathName;

		private static FreeAllocInternalHandler FreeAllocInternal;

		private unsafe static PersistentManager* PersistentManager => *(PersistentManager**)PersistentManagerPtr.ToPointer();

		public static void Init()
		{
			IntPtr baseAddress = (Process.GetCurrentProcess().Modules.Cast<ProcessModule>().FirstOrDefault(IsUnityPlayer) ?? Process.GetCurrentProcess().MainModule).BaseAddress;
			PersistentManagerPtr = baseAddress + 28557672;
			InstanceIDToSerializedObjectIdentifier = Marshal.GetDelegateForFunctionPointer<InstanceIDToSerializedObjectIdentifierHandler>(baseAddress + 6881312);
			PersistentManagerGetPathName = Marshal.GetDelegateForFunctionPointer<PersistentManagerGetPathNameHandler>(baseAddress + 6809328);
			FreeAllocInternal = Marshal.GetDelegateForFunctionPointer<FreeAllocInternalHandler>(baseAddress + 2593600);
			static bool IsUnityPlayer(ProcessModule p)
			{
				return p.ModuleName.ToLowerInvariant().Contains("unityplayer");
			}
		}

		public static long GetAssetPathID(Object obj)
		{
			if (!Object.op_Implicit(obj))
			{
				return 0L;
			}
			return GetAssetPathID(obj.GetInstanceID());
		}

		public unsafe static long GetAssetPathID(int instanceID)
		{
			SerializedObjectIdentifier serializedObjectIdentifier = default(SerializedObjectIdentifier);
			IntPtr remapper = PersistentManager->Remapper;
			InstanceIDToSerializedObjectIdentifier(remapper, instanceID, &serializedObjectIdentifier);
			return serializedObjectIdentifier.pathID;
		}

		public static string GetPathName(Object obj)
		{
			if (!Object.op_Implicit(obj))
			{
				return "";
			}
			return GetPathName(obj.GetInstanceID());
		}

		public unsafe static string GetPathName(int instanceID)
		{
			StringStorageDefaultV2 stringStorageDefaultV = default(StringStorageDefaultV2);
			PersistentManagerGetPathName(PersistentManager, &stringStorageDefaultV, instanceID);
			if (stringStorageDefaultV.data_repr != StringRepresentation.Embedded && (stringStorageDefaultV.union.heap.data == 0 || stringStorageDefaultV.union.heap.size == 0L))
			{
				return "";
			}
			if (stringStorageDefaultV.data_repr == StringRepresentation.Embedded)
			{
				return Marshal.PtrToStringAnsi((IntPtr)stringStorageDefaultV.union.embedded.data);
			}
			string text = Marshal.PtrToStringAnsi(stringStorageDefaultV.union.heap.data, (int)stringStorageDefaultV.union.heap.size);
			if (text != null)
			{
				FreeAllocInternal(stringStorageDefaultV.union.heap.data, stringStorageDefaultV.label, IntPtr.Zero, 0);
				return text;
			}
			return "";
		}
	}
}
namespace R2API.AutoVersionGen
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal class AutoVersionAttribute : Attribute
	{
	}
}
namespace R2API.NativeStructs
{
	[StructLayout(LayoutKind.Explicit)]
	public struct PersistentManager
	{
		[FieldOffset(88)]
		public IntPtr Remapper;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct SerializedObjectIdentifier
	{
		public int fileID;

		public long pathID;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 8)]
	public struct StringStorageDefaultV2
	{
		public StringStorageDefaultV2Union union;

		public StringRepresentation data_repr;

		public int label;
	}
	[StructLayout(LayoutKind.Explicit, Pack = 8)]
	public struct StringStorageDefaultV2Union
	{
		[FieldOffset(0)]
		public StackAllocatedRepresentationV2 embedded;

		[FieldOffset(0)]
		public HeapAllocatedRepresentationV2 heap;
	}
	public struct StackAllocatedRepresentationV2
	{
		public unsafe fixed byte data[25];
	}
	public struct HeapAllocatedRepresentationV2
	{
		public nint data;

		public ulong capacity;

		public ulong size;
	}
	public enum StringRepresentation
	{
		Heap,
		Embedded,
		External
	}
}