using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using ModelReplacement.AvatarBodyUpdater;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("LethalStarRail")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LethalStarRail")]
[assembly: AssemblyTitle("LethalStarRail")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
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;
		}
	}
}
namespace LethalStarRail
{
	public class MRANAXA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Anaxa";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRARGENTI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Argenti";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRARLAN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Arlan";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRAVENTURINE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Aventurine";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRAVENTURINE_MMD : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Aventurine_MMD";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRBLADE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Blade";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRBOOTHILL : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Boothill";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRCAELUS : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Caelus";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRCAELUS_HARMONY : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Caelus_Harmony";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRCAELUS_REMEMBRANCE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Caelus_Remembrance";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRDANHENG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "DanHeng";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRDANHENGIL : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "DanHeng-IL";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRGALLAGHER : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Gallagher";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRGEPARD : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Gepard";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRJIAOQIU : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Jiaoqiu";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRJINGYUAN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "JingYuan";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRLUKA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Luka";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRLUOCHA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Luocha";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRMISHA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Misha";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRMOZE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Moze";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRMYDEI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Mydei";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRPHAINON : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Phainon";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRRATIO : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Ratio";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRSAMPO : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Sampo";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRSUNDAY : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Sunday";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRWELT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Welt";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRYANQING : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Yanqing";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSACHERON : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Acheron";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSACHERON_NIHILITY : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Nihility";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSAGLAEA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Aglaea";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSASTA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Asta";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSBAILU : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Bailu";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSBLACKSWAN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Blackswan";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSBRONYA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Bronya";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSCASTORICE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Castorice";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSCIPHER : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Cipher";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSCLARA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Clara";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSFEIXIAO : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Feixiao";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSFIREFLY : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Firefly";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSFUGUE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Fugue";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSFUXUAN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Fuxuan";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSGUINAIFEN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Guinaifen";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHANABI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Sparkle";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHANYA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "HANYA";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHERTA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Herta";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHIMEKO : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Himeko";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHOOK : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Hook";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHUOHUO : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "HUOHUO";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHYACINE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Hyacine";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSJADE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Jade";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSJINGLIU : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Jingliu";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSKAFKA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Kafka";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSLINGSHA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Lingsha";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSLYNX : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Lynx";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSMARCH_NASCENTSPRING : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "March7th-NascentSpring";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSMARCH_PRESERVATION : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "March7th-Default";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSMARCH_THEHUNT : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "March7th-TheHunt";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSNATASHA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Natasha";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSNUMPAZ : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Numpaz";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSPELA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Pela";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSQINGQUE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Qingque";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSRAPPA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Rappa";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSROBIN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Robin";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSRUANMEI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Ruanmei";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSEELE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Seele";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSERVAL : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Serval";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSILVERWOLF : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Silverwolf";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSTELLE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Stelle";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSTELLE_HARMONY : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Stelle_Harmony";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSTELLE_REMEMBRANCE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Stelle_Remembrance";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSUSHANG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Sushang";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSTINGYUN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Tingyun";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSTOPAZ : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Topaz";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSXUEYI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Xueyi";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSYUKONG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Yukong";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSYUNLI : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Yunli";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class POMPOM : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Pompom";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class THEHERTA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "TheHerta";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class TRIANNE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Trianne";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class TRIBBIE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Tribbie";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class TRIBIOS : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Tribios";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class TRINNON : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Trinnon";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class SAM : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Sam";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class SVAROG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Svarog";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSCOCOLIA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Cocolia";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MRYINGXING : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Yingxing";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSBAIHENG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Baiheng";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class AVENTURINE_BOSS : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Aventurine_Boss";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class BLADE_SESAMECATCAKE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Blade_SesameCatCake";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class FLAME_REAVER : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Flame_Reaver";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class PINK_JESUS : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Cyrene";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSHYACINICA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Hyacinica";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class YINGXING_SESAMECATCAKE : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Yingxing_SesameCatCake";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class SVARA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Svara";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSSIOBHAN : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Siobhan";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class SCREWLLUM : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Screwllum";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class KAKAVASHA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Kakavasha";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class DANFENG : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "DanFeng";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class MSARTORIA : BodyReplacementBase
	{
		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "Saber";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void AddModelScripts()
		{
			CharacterFeature characterFeature = ((Component)base.replacementModel.GetComponentInChildren<SkinnedMeshRenderer>()).gameObject.AddComponent(typeof(CharacterFeature)) as CharacterFeature;
			characterFeature.player = ((BodyReplacementBase)this).controller;
			characterFeature.SetPlayer(((BodyReplacementBase)this).LoadAssetsAndReturnModel().gameObject.GetComponentInChildren<OffsetBuilder>());
		}
	}
	public class CharacterFeature : MonoBehaviour
	{
		private CharacterFeature modelScript;

		protected VoicePlayerState voice;

		public PlayerControllerB player;

		private PlayerControllerB nearbyPlayer = null;

		private readonly Harmony harmony = new Harmony("ZephyModelScripts");

		private static bool harmonyPatched;

		private float distanceToPlayer = 30f;

		private float texture_offset = 0f;

		private string modelName;

		private Vector3 rootScale = Vector3.zero;

		private Vector3 LastPosition = Vector3.zero;

		private bool cheat_scaling = false;

		private Vector3 tempPosition;

		private Transform headBone;

		private Transform eyeBone;

		private Transform dummyEyeBone;

		private Vector3 DefaultEye_EulerAngles;

		private float FieldOfView = 60f;

		private float DesireAngle;

		private float blendShapeValue = 0f;

		private bool isRandomEnable = true;

		private bool EyeLook_Condition;

		private float Mem_blendShapeValue = 0f;

		private float Catcake_blendShapeValue = 0f;

		private float Ica_blendShapeValue = 0f;

		private bool isRandomEnable_Mem = true;

		private bool isRandomEnable_catcake = true;

		private bool isRandomEnable_Ica = true;

		public float defaultBlendValue = 0f;

		public float maxBlendValue = 50f;

		private int mouthIndex;

		private int eyesIndex;

		private int MemEyesIndex;

		private int OnScare;

		private int random = 0;

		private int random_Mem = 0;

		private int random_Catcake = 0;

		private int random_Ica = 0;

		private float interval = 0f;

		private float remainingTime = 60f;

		private float timer = 0f;

		private bool isOtherPlayerSpeaking = false;

		private readonly List<string> eyesName = new List<string> { "まばたき" };

		private readonly List<string> mouthName = new List<string> { "あ" };

		private readonly List<string> faceEmotion = new List<string> { "OnScare", "OnDeath 1", "OnDeath 2" };

		private readonly Dictionary<string, Vector3> SpecialScaleList = new Dictionary<string, Vector3>
		{
			{
				"Aventurine_Boss",
				Vector3.one
			},
			{
				"Baiheng",
				new Vector3(0.95f, 0.95f, 0.95f)
			},
			{
				"Blade",
				new Vector3(1.08f, 1.08f, 1.08f)
			},
			{
				"Caelus",
				new Vector3(0.99f, 0.99f, 0.99f)
			},
			{
				"Castorice",
				new Vector3(0.91f, 0.91f, 0.91f)
			},
			{
				"Cipher",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Cyrene",
				new Vector3(0.78f, 0.78f, 0.78f)
			},
			{
				"DanHeng",
				new Vector3(0.99f, 0.99f, 0.99f)
			},
			{
				"Feixiao",
				new Vector3(0.99f, 0.99f, 0.99f)
			},
			{
				"Fugue",
				new Vector3(0.91f, 0.91f, 0.91f)
			},
			{
				"Fuxuan",
				new Vector3(0.77f, 0.77f, 0.77f)
			},
			{
				"Hook",
				new Vector3(0.67f, 0.67f, 0.67f)
			},
			{
				"Hyacinica",
				new Vector3(0.81f, 0.81f, 0.81f)
			},
			{
				"Jade",
				Vector3.one
			},
			{
				"Numpaz",
				new Vector3(0.94f, 0.94f, 0.94f)
			},
			{
				"Robin",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Phainon",
				new Vector3(1.07f, 1.07f, 1.07f)
			},
			{
				"Siobhan",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Silverwolf",
				new Vector3(0.9f, 0.9f, 0.9f)
			},
			{
				"Seele",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Sunday",
				new Vector3(0.99f, 0.99f, 0.99f)
			},
			{
				"Stelle",
				new Vector3(0.97f, 0.97f, 0.97f)
			},
			{
				"Svara",
				new Vector3(1.49f, 1.49f, 1.49f)
			},
			{
				"TheHerta",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Yingxing",
				new Vector3(1.08f, 1.08f, 1.08f)
			},
			{
				"Yukong",
				new Vector3(0.97f, 0.97f, 0.97f)
			}
		};

		private readonly List<string> blacklist = new List<string> { "Aventurine_Boss", "Flame_Reaver", "Sam", "Screwllum", "Svara", "Svarog", "Jiaoqiu", "Trinnon" };

		public bool isHelmetDisable => Plugin.disableHelmet.Value;

		public bool isAllowHardcore => Plugin.allowHardcore.Value;

		public bool enableBlindfold => Plugin.enableBlindfold.Value;

		public bool isDeveloperMode => Plugin.developerMode.Value;

		public float sensitivity => Plugin.voiceSensitivity.Value;

		public void SetPlayer(OffsetBuilder offsetBuilder)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0063: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			modelName = ((Object)offsetBuilder).name;
			if (!blacklist.Contains(modelName))
			{
				voiceRecognize();
			}
			Regex regex = new Regex("^(\\w+)[_-].*");
			Match match = regex.Match(((Object)offsetBuilder).name);
			if ((Object)player == (Object)StartOfRound.Instance.localPlayerController)
			{
				if (((Object)offsetBuilder).name == "Svarog" || ((Object)offsetBuilder).name == "Svara")
				{
					HUDManager.Instance.DisplayTip("MODEL WARNING:", ((Object)offsetBuilder).name + " has a large hitbox, BE CAREFUL !", true, false, "LC_Tip1");
				}
				else if (((Object)offsetBuilder).name == "Saber")
				{
					HUDManager.Instance.DisplayTip("Note: ", "Model still in development...", false, false, "LC_Tip1");
				}
			}
			if (SpecialScaleList.ContainsKey(((Object)offsetBuilder).name))
			{
				((Component)player).gameObject.transform.localScale = SpecialScaleList[((Object)offsetBuilder).name];
			}
			else if (match.Success)
			{
				string value = match.Groups[1].Value;
				((Component)player).gameObject.transform.localScale = (SpecialScaleList.ContainsKey(value) ? SpecialScaleList[value] : offsetBuilder.rootScale);
			}
			else
			{
				((Component)player).gameObject.transform.localScale = offsetBuilder.rootScale;
			}
			rootScale = ((Component)player).gameObject.transform.localScale;
		}

		private void ForceScaling()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0150: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)player).gameObject.transform.localScale.y > 1f && !player.inTerminalMenu && !player.inSpecialInteractAnimation)
			{
				if (player.isCrouching)
				{
					if (!cheat_scaling)
					{
						cheat_scaling = true;
					}
					if (((Component)player).gameObject.transform.localScale != Vector3.one)
					{
						((Component)player).gameObject.transform.localScale = Vector3.one;
					}
				}
			}
			else if (cheat_scaling && !player.isCrouching)
			{
				if (rootScale != Vector3.zero && rootScale != ((Component)player).gameObject.transform.localScale)
				{
					((Component)player).gameObject.transform.localScale = rootScale;
				}
				cheat_scaling = false;
			}
			if ((Object)player == (Object)StartOfRound.Instance.localPlayerController && !cheat_scaling && rootScale != Vector3.zero && rootScale != ((Component)player).gameObject.transform.localScale && !player.inTerminalMenu)
			{
				((Component)player).gameObject.transform.localScale = rootScale;
			}
		}

		private static Dictionary<string, Transform> GetBoneMap(Transform[] OriginalBone)
		{
			Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>();
			foreach (Transform val in OriginalBone)
			{
				if ((Object)(object)val != (Object)null && !dictionary.ContainsKey(((Object)val).name))
				{
					dictionary.Add(((Object)val).name, val);
				}
			}
			return dictionary;
		}

		private void VFX(Material material)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			texture_offset += Time.deltaTime / 5f;
			if (texture_offset < 10f)
			{
				material.mainTextureOffset = new Vector2(texture_offset, texture_offset);
			}
			else
			{
				texture_offset = 0f;
			}
		}

		private void voiceRecognize()
		{
			//IL_002b: 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_0044: Expected O, but got Unknown
			//IL_0044: Expected O, but got Unknown
			StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
			voice = player.voicePlayerState;
			if (voice == null && (Object)player == (Object)StartOfRound.Instance.localPlayerController)
			{
				voice = StartOfRound.Instance.voiceChatModule.FindPlayer(StartOfRound.Instance.voiceChatModule.LocalPlayerName);
			}
		}

		private void ActivateMouthMovement()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if ((Object)StartOfRound.Instance.voiceChatModule == (Object)null)
			{
				return;
			}
			if (voice == null)
			{
				voiceRecognize();
				return;
			}
			float num = Mathf.Clamp(Map(voice.Amplitude * sensitivity, 0f, 0.2f, defaultBlendValue, maxBlendValue), defaultBlendValue, maxBlendValue);
			float num2 = ((voice.IsSpeaking && !player.isPlayerDead) ? num : defaultBlendValue);
			if (mouthIndex != -1)
			{
				((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(mouthIndex, num2);
			}
		}

		private void isBlinking(bool blink)
		{
			if (!blink)
			{
				return;
			}
			interval += Time.deltaTime;
			((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyesIndex, defaultBlendValue);
			if (!isRandomEnable)
			{
				blendShapeValue += Time.deltaTime * 5000f;
				if (random == Mathf.FloorToInt(interval) && interval % 1f < 0.3f)
				{
					((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyesIndex, Mathf.Clamp(blendShapeValue, defaultBlendValue, 100f));
				}
			}
			else
			{
				random = Random.Range(0, 5);
				isRandomEnable = false;
			}
			if (modelName == "Caelus_Remembrance" || modelName == "Stelle_Remembrance")
			{
				((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(MemEyesIndex, defaultBlendValue);
				if (!isRandomEnable_Mem)
				{
					Mem_blendShapeValue += Time.deltaTime * 5000f;
					if (random_Mem == Mathf.FloorToInt(interval) && interval % 1f < 0.3f)
					{
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(MemEyesIndex, Mathf.Clamp(Mem_blendShapeValue, defaultBlendValue, 100f));
					}
				}
				else
				{
					random_Mem = Random.Range(0, 5);
					isRandomEnable_Mem = false;
				}
			}
			if (modelName == "Blade_SesameCatCake" || modelName == "Yingxing_SesameCatCake")
			{
				int blendShapeIndex = ((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh.GetBlendShapeIndex("Blink");
				((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(blendShapeIndex, defaultBlendValue);
				if (!isRandomEnable_catcake)
				{
					Catcake_blendShapeValue += Time.deltaTime * 5000f;
					if (random_Catcake == Mathf.FloorToInt(interval) && interval % 1f < 0.3f)
					{
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(blendShapeIndex, Mathf.Clamp(Catcake_blendShapeValue, defaultBlendValue, 100f));
					}
				}
				else
				{
					random_Catcake = Random.Range(0, 5);
					isRandomEnable_catcake = false;
				}
			}
			if (modelName == "Hyacinica")
			{
				int blendShapeIndex2 = ((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh.GetBlendShapeIndex("Ica_eyes");
				((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(blendShapeIndex2, defaultBlendValue);
				if (!isRandomEnable_Ica)
				{
					Ica_blendShapeValue += Time.deltaTime * 5000f;
					if (random_Ica == Mathf.FloorToInt(interval) && interval % 1f < 0.3f)
					{
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(blendShapeIndex2, Mathf.Clamp(Ica_blendShapeValue, defaultBlendValue, 100f));
					}
				}
				else
				{
					random_Ica = Random.Range(0, 5);
					isRandomEnable_Ica = false;
				}
			}
			if (interval > 5f)
			{
				interval = 0f;
				blendShapeValue = 0f;
				Mem_blendShapeValue = 0f;
				if (!isRandomEnable)
				{
					isRandomEnable = true;
				}
				if (!isRandomEnable_Mem)
				{
					isRandomEnable_Mem = true;
				}
				if (!isRandomEnable_Ica)
				{
					isRandomEnable_Ica = true;
				}
			}
		}

		private float Map(float value, float min1, float max1, float min2, float max2)
		{
			float num = (value - min1) / (max1 - min1);
			return num * (max2 - min2) + min2;
		}

		private void EyeLimitation(Vector3 target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = target - ((Component)headBone).transform.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			DesireAngle = Vector3.Angle(headBone.up, normalized);
		}

		private void LookAtTarget(Vector3 targetPosition, bool active)
		{
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (active)
			{
				EyeLimitation(targetPosition);
				float num = Vector3.Distance(((Component)player).transform.position, targetPosition);
				if (num > 2.2f && num < 10f && Mathf.Abs(DesireAngle) > 1f && Mathf.Abs(DesireAngle) < 16f)
				{
					dummyEyeBone.position = eyeBone.position;
					dummyEyeBone.LookAt(targetPosition);
					if (dummyEyeBone.localEulerAngles.x > 270f && dummyEyeBone.localEulerAngles.x < 286f)
					{
						eyeBone.localRotation = Quaternion.Slerp(eyeBone.localRotation, dummyEyeBone.localRotation, Time.deltaTime * 10f);
					}
					eyeBone.localRotation = Quaternion.Slerp(eyeBone.localRotation, dummyEyeBone.localRotation, Time.deltaTime * 10f);
				}
				else
				{
					eyeBone.localRotation = Quaternion.Slerp(eyeBone.localRotation, Quaternion.Euler(DefaultEye_EulerAngles), Time.deltaTime * 5f);
				}
			}
			else
			{
				eyeBone.localRotation = Quaternion.Slerp(eyeBone.localRotation, Quaternion.Euler(DefaultEye_EulerAngles), Time.deltaTime * 5f);
			}
		}

		private void GetNearbyPlayers()
		{
			//IL_0030: 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)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val != (Object)(object)player)
				{
					float num = Vector3.Distance(((Component)val).transform.position, ((Component)player).transform.position);
					if (num < 30f && ((Object)(object)nearbyPlayer == (Object)null || num < distanceToPlayer))
					{
						nearbyPlayer = val;
						distanceToPlayer = num;
					}
				}
			}
			if ((Object)(object)nearbyPlayer != (Object)null)
			{
				ProceedNearbyPlayer(nearbyPlayer);
			}
		}

		private void ProceedNearbyPlayer(PlayerControllerB _nearbyPlayer)
		{
			//IL_005c: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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)
			Transform[] bones = ((Component)_nearbyPlayer).GetComponentInChildren<SkinnedMeshRenderer>().bones;
			foreach (Transform val in bones)
			{
				if (!(((Object)val).name == "spine.004") || modelName == null || blacklist.Contains(modelName))
				{
					continue;
				}
				if (LastPosition == Vector3.zero)
				{
					LastPosition = ((Component)_nearbyPlayer).transform.position;
				}
				if (_nearbyPlayer.performingEmote || LastPosition != ((Component)_nearbyPlayer).transform.position)
				{
					LookAtTarget(val.position + new Vector3(0f, 0.2f, 0f), !player.performingEmote && !player.isSprinting);
					LastPosition = ((Component)_nearbyPlayer).transform.position;
					if (timer != 0f)
					{
						timer = 0f;
					}
				}
				else
				{
					timer += Time.deltaTime;
					if (timer < 5f)
					{
						LookAtTarget(val.position + new Vector3(0f, 0.25f, 0f), !player.performingEmote && !player.isSprinting);
					}
					else
					{
						LookAtTarget(val.position + new Vector3(0f, 0.25f, 0f), active: false);
					}
				}
			}
		}

		private void Awake()
		{
			if (!harmonyPatched)
			{
				harmony.PatchAll(typeof(CharacterFeature));
				harmonyPatched = true;
			}
			modelScript = this;
		}

		private void OnEnable()
		{
			if ((Object)(object)player == (Object)(object)StartOfRound.Instance.localPlayerController && isHelmetDisable)
			{
				((Component)player.localVisor).gameObject.SetActive(false);
			}
		}

		private void Start()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			Mesh sharedMesh = ((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh;
			mouthIndex = sharedMesh.GetBlendShapeIndex(mouthName[0]);
			eyesIndex = sharedMesh.GetBlendShapeIndex(eyesName[0]);
			OnScare = sharedMesh.GetBlendShapeIndex(faceEmotion[0]);
			if (modelName == "Caelus_Remembrance" || modelName == "Stelle_Remembrance")
			{
				MemEyesIndex = sharedMesh.GetBlendShapeIndex("Mem_eyes");
			}
			GameObject val = new GameObject("dummyBone");
			dummyEyeBone = val.transform;
			if (GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones) != null)
			{
				if (GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones).ContainsKey("EyeLook"))
				{
					eyeBone = GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones)["EyeLook"];
					DefaultEye_EulerAngles = eyeBone.localEulerAngles;
					dummyEyeBone.parent = eyeBone.parent;
					dummyEyeBone.rotation = eyeBone.rotation;
					dummyEyeBone.position = eyeBone.position;
				}
				else if (!blacklist.Contains(modelName) && isDeveloperMode)
				{
					HUDManager.Instance.DisplayTip("MODEL WARNING:", "Model is missing eye's control rig", true, false, "LC_Tip1");
				}
				if (GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones).ContainsKey("Head"))
				{
					headBone = GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones)["Head"];
				}
			}
			if (modelName == "Jingliu")
			{
				((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(sharedMesh.GetBlendShapeIndex("Blindfold"), enableBlindfold ? 0f : 100f);
			}
		}

		private void Update()
		{
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			if (player.isPlayerDead)
			{
				return;
			}
			ForceScaling();
			GetNearbyPlayers();
			if (!blacklist.Contains(modelName))
			{
				ActivateMouthMovement();
				isBlinking(eyesIndex != -1);
			}
			if (modelName == "Caelus_Remembrance" || modelName == "Stelle_Remembrance" || modelName == "Hyacinica")
			{
				Transform[] bones = ((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones;
				foreach (Transform val in bones)
				{
					if (((Object)val).name == "Mem_Hips")
					{
						float num = Mathf.Sin(Time.time) * 5f / 8500f;
						val.localPosition = new Vector3(val.localPosition.x, val.localPosition.y, val.localPosition.z + num);
					}
					if (((Object)val).name == "Ica_Hips")
					{
						float num2 = Mathf.Sin(Time.time) * 5f / 8500f;
						val.localPosition = new Vector3(val.localPosition.x, val.localPosition.y, val.localPosition.z + num2);
					}
				}
			}
			if (!(modelName == "Huohuo"))
			{
				return;
			}
			Material[] sharedMaterials = ((Renderer)((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>()).sharedMaterials;
			foreach (Material val2 in sharedMaterials)
			{
				if (((Object)val2).name == "尾巴火焰")
				{
					VFX(val2);
				}
				if (((Object)val2).name == "尾巴火焰1")
				{
					VFX(val2);
				}
			}
		}

		[HarmonyPatch(typeof(Terminal), "BeginUsingTerminal")]
		[HarmonyPostfix]
		private static void EnableModelAdjust()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			CharacterFeature characterFeature = Object.FindObjectOfType<CharacterFeature>();
			if ((Object)(object)characterFeature != (Object)null && !characterFeature.isAllowHardcore)
			{
				((Component)localPlayerController).gameObject.transform.localScale = Vector3.one;
			}
		}

		[HarmonyPatch(typeof(BodyReplacementBase), "OnDeath")]
		[HarmonyPrefix]
		private static void FaceEmoteOnDeath()
		{
			CharacterFeature characterFeature = Object.FindObjectOfType<CharacterFeature>();
			SkinnedMeshRenderer component = ((Component)characterFeature).gameObject.GetComponent<SkinnedMeshRenderer>();
			int blendShapeIndex = component.sharedMesh.GetBlendShapeIndex(characterFeature.faceEmotion[1]);
			int blendShapeIndex2 = component.sharedMesh.GetBlendShapeIndex(characterFeature.faceEmotion[2]);
			int blendShapeIndex3 = component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[0]);
			if ((component.sharedMesh.GetBlendShapeIndex("Blindfold") != -1) ^ (component.GetBlendShapeWeight(component.sharedMesh.GetBlendShapeIndex("Blindfold")) != 100f))
			{
				if (blendShapeIndex != -1 && blendShapeIndex2 != -1)
				{
					if (component.GetBlendShapeWeight(blendShapeIndex) != 100f && component.GetBlendShapeWeight(blendShapeIndex2) != 100f)
					{
						component.SetBlendShapeWeight((Random.Range(1, 10) % 2 == 0) ? blendShapeIndex : blendShapeIndex2, 100f);
					}
				}
				else if (blendShapeIndex != -1 && component.GetBlendShapeWeight(blendShapeIndex) != 100f)
				{
					component.SetBlendShapeWeight(blendShapeIndex, 100f);
				}
			}
			else
			{
				component.SetBlendShapeWeight(blendShapeIndex3, 100f);
			}
		}

		[HarmonyPatch(typeof(ModelReplacementAPI), "RemovePlayerModelReplacement")]
		[HarmonyPrefix]
		private static void DisableModelAdjustment(PlayerControllerB player)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			((Component)player.localVisor).gameObject.SetActive(true);
			((Component)player).gameObject.transform.localScale = Vector3.one;
			((Component)player.gameplayCamera).transform.localPosition = Vector3.zero;
		}
	}
	[BepInPlugin("com.zephy.lethal_starrail", "Lethal Company x Honkai Star Rail", "0.2.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal const string LethalStarRailGuid = "com.zephy.lethal_starrail";

		public static ConfigFile config;

		public static ConfigEntry<float> voiceSensitivity { get; private set; }

		public static ConfigEntry<bool> allowHardcore { get; private set; }

		public static ConfigEntry<bool> disableHelmet { get; private set; }

		public static ConfigEntry<bool> enableBlindfold { get; private set; }

		public static ConfigEntry<bool> scareForEnemies { get; private set; }

		public static ConfigEntry<bool> developerMode { get; private set; }

		private static void InitConfig()
		{
			voiceSensitivity = config.Bind<float>("Voice sensitivity for mouth movement", "Sensitivity Value", 50f, "Number from 1 to 100");
			allowHardcore = config.Bind<bool>("Allow model to use accurate camera while on Terminal", "Confirm", false, "True or false");
			disableHelmet = config.Bind<bool>("Disable helmet while using the suit", "Confirm", true, "True or false");
			enableBlindfold = config.Bind<bool>("Enable blindfold on Jingliu", "Confirm", false, "True or false");
			developerMode = config.Bind<bool>("Enable developer mode", "Confirm", false, "True or false");
		}

		private void Awake()
		{
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f0: Expected O, but got Unknown
			config = ((BaseUnityPlugin)this).Config;
			InitConfig();
			Assets.PopulateAssets();
			Dictionary<string, Type> dictionary = new Dictionary<string, Type>();
			dictionary.Add("Caelus", typeof(MRCAELUS));
			dictionary.Add("Stelle", typeof(MSSTELLE));
			dictionary.Add("March7th-Default", typeof(MSMARCH_PRESERVATION));
			dictionary.Add("DanHeng", typeof(MRDANHENG));
			dictionary.Add("Welt", typeof(MRWELT));
			dictionary.Add("Himeko", typeof(MSHIMEKO));
			dictionary.Add("Clara", typeof(MSCLARA));
			dictionary.Add("Bronya", typeof(MSBRONYA));
			dictionary.Add("Seele", typeof(MSSEELE));
			dictionary.Add("Asta", typeof(MSASTA));
			dictionary.Add("Arlan", typeof(MRARLAN));
			dictionary.Add("Bailu", typeof(MSBAILU));
			dictionary.Add("Gepard", typeof(MRGEPARD));
			dictionary.Add("Herta", typeof(MSHERTA));
			dictionary.Add("Hook", typeof(MSHOOK));
			dictionary.Add("JingYuan", typeof(MRJINGYUAN));
			dictionary.Add("Natasha", typeof(MSNATASHA));
			dictionary.Add("Pela", typeof(MSPELA));
			dictionary.Add("Sampo", typeof(MRSAMPO));
			dictionary.Add("Sushang", typeof(MSSUSHANG));
			dictionary.Add("Tingyun", typeof(MSTINGYUN));
			dictionary.Add("Qingque", typeof(MSQINGQUE));
			dictionary.Add("Serval", typeof(MSSERVAL));
			dictionary.Add("Yanqing", typeof(MRYANQING));
			dictionary.Add("Pompom", typeof(POMPOM));
			dictionary.Add("Blade", typeof(MRBLADE));
			dictionary.Add("DanHeng-IL", typeof(MRDANHENGIL));
			dictionary.Add("Fuxuan", typeof(MSFUXUAN));
			dictionary.Add("Guinaifen", typeof(MSGUINAIFEN));
			dictionary.Add("Jingliu", typeof(MSJINGLIU));
			dictionary.Add("Kafka", typeof(MSKAFKA));
			dictionary.Add("Luka", typeof(MRLUKA));
			dictionary.Add("Luocha", typeof(MRLUOCHA));
			dictionary.Add("Lynx", typeof(MSLYNX));
			dictionary.Add("Silverwolf", typeof(MSSILVERWOLF));
			dictionary.Add("Yukong", typeof(MSYUKONG));
			dictionary.Add("Topaz", typeof(MSTOPAZ));
			dictionary.Add("Acheron", typeof(MSACHERON));
			dictionary.Add("Nihility", typeof(MSACHERON_NIHILITY));
			dictionary.Add("Argenti", typeof(MRARGENTI));
			dictionary.Add("Aventurine", typeof(MRAVENTURINE));
			dictionary.Add("Aventurine_MMD", typeof(MRAVENTURINE_MMD));
			dictionary.Add("Blackswan", typeof(MSBLACKSWAN));
			dictionary.Add("Ratio", typeof(MRRATIO));
			dictionary.Add("Gallagher", typeof(MRGALLAGHER));
			dictionary.Add("Hanya", typeof(MSHANYA));
			dictionary.Add("Huohuo", typeof(MSHUOHUO));
			dictionary.Add("Misha", typeof(MRMISHA));
			dictionary.Add("Ruanmei", typeof(MSRUANMEI));
			dictionary.Add("Sparkle", typeof(MSHANABI));
			dictionary.Add("Xueyi", typeof(MSXUEYI));
			dictionary.Add("Boothill", typeof(MRBOOTHILL));
			dictionary.Add("Caelus_Harmony", typeof(MRCAELUS_HARMONY));
			dictionary.Add("Firefly", typeof(MSFIREFLY));
			dictionary.Add("Jade", typeof(MSJADE));
			dictionary.Add("Robin", typeof(MSROBIN));
			dictionary.Add("Stelle_Harmony", typeof(MSSTELLE_HARMONY));
			dictionary.Add("Aglaea", typeof(MSAGLAEA));
			dictionary.Add("Castorice", typeof(MSCASTORICE));
			dictionary.Add("Feixiao", typeof(MSFEIXIAO));
			dictionary.Add("Fugue", typeof(MSFUGUE));
			dictionary.Add("Jiaoqiu", typeof(MRJIAOQIU));
			dictionary.Add("Lingsha", typeof(MSLINGSHA));
			dictionary.Add("March7th-TheHunt", typeof(MSMARCH_THEHUNT));
			dictionary.Add("Moze", typeof(MRMOZE));
			dictionary.Add("Phainon", typeof(MRPHAINON));
			dictionary.Add("Rappa", typeof(MSRAPPA));
			dictionary.Add("Sunday", typeof(MRSUNDAY));
			dictionary.Add("Yunli", typeof(MSYUNLI));
			dictionary.Add("TheHerta", typeof(THEHERTA));
			dictionary.Add("Anaxa", typeof(MRANAXA));
			dictionary.Add("Hyacine", typeof(MSHYACINE));
			dictionary.Add("Mydei", typeof(MRMYDEI));
			dictionary.Add("Tribbie", typeof(TRIBBIE));
			dictionary.Add("Trianne", typeof(TRIANNE));
			dictionary.Add("Trinnon", typeof(TRINNON));
			dictionary.Add("Tribios", typeof(TRIBIOS));
			dictionary.Add("March7th-NascentSpring", typeof(MSMARCH_NASCENTSPRING));
			dictionary.Add("Caelus_Remembrance", typeof(MRCAELUS_REMEMBRANCE));
			dictionary.Add("Stelle_Remembrance", typeof(MSSTELLE_REMEMBRANCE));
			dictionary.Add("Numpaz", typeof(MSNUMPAZ));
			dictionary.Add("Cipher", typeof(MSCIPHER));
			dictionary.Add("Sam", typeof(SAM));
			dictionary.Add("Svarog", typeof(SVAROG));
			dictionary.Add("Cocolia", typeof(MSCOCOLIA));
			dictionary.Add("Yingxing", typeof(MRYINGXING));
			dictionary.Add("Baiheng", typeof(MSBAIHENG));
			dictionary.Add("Aventurine_Boss", typeof(A