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 CharacterFeature : MonoBehaviour
	{
		private CharacterFeature modelScript;

		protected VoicePlayerState voice;

		public PlayerControllerB player;

		private PlayerControllerB nearbyPlayer = null;

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

		private float distanceToPlayer = 30f;

		private float texture_offset = 0f;

		private string modelName;

		private Vector3 rootScale = Vector3.zero;

		private Vector3 LastPosition = Vector3.zero;

		private Transform eyeBone;

		private Transform dummyEyeBone;

		private Vector3 DefaultEye_EulerAngles;

		private float FieldOfView = 60f;

		private float LimitHorizontalAngle;

		private float blendShapeValue = 0f;

		private float Mem_blendShapeValue = 0f;

		private bool isRandomEnable = true;

		private bool isRandomEnable_Mem = true;

		private bool EyeLook_Condition;

		public float defaultBlendValue = 0f;

		public float maxBlendValue = 50f;

		private int mouthIndex;

		private int eyesIndex;

		private int mouthIndex_fear;

		private int eyesIndex_fear;

		private int eyebrowIndex_fear;

		private int eyebrowIndex;

		private int MemEyesIndex;

		private int random = 0;

		private int random_Mem = 0;

		private float interval = 0f;

		private float remainingTime = 60f;

		private float timer = 0f;

		private bool isEnemyNearby = false;

		private bool PlayerIsDead = false;

		private float nearbyPlayer_volume = 0f;

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

		private readonly List<string> eyesName = new List<string> { "まばたき", "はぅ", "なごみ", "驚かす", "びっくり" };

		private readonly List<string> mouthName = new List<string> { "あ", "口角下げ", "怒った", "い" };

		private readonly List<string> eyebrowName = new List<string> { "上", "悲しい", "にこり" };

		private readonly Dictionary<string, Vector3> SpecialScaleList = new Dictionary<string, Vector3>
		{
			{
				"Aventurine_Boss",
				Vector3.one
			},
			{
				"Baiheng",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"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)
			},
			{
				"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)
			},
			{
				"Jade",
				Vector3.one
			},
			{
				"Numpaz",
				new Vector3(0.94f, 0.94f, 0.94f)
			},
			{
				"Robin",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Silverwolf",
				new Vector3(0.9f, 0.9f, 0.9f)
			},
			{
				"Sunday",
				new Vector3(0.99f, 0.99f, 0.99f)
			},
			{
				"Stelle",
				new Vector3(0.97f, 0.97f, 0.97f)
			},
			{
				"TheHerta",
				new Vector3(0.93f, 0.93f, 0.93f)
			},
			{
				"Yukong",
				new Vector3(0.97f, 0.97f, 0.97f)
			}
		};

		public bool isHelmetDisable => Plugin.disableHelmet.Value;

		public bool isAllowHardcore => Plugin.allowHardcore.Value;

		public float sensitivity => Plugin.voiceSensitivity.Value;

		public void SetPlayer(OffsetBuilder offsetBuilder)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			voiceActivate();
			modelName = ((Object)offsetBuilder).name;
			Regex regex = new Regex("^(\\w+)[_-].*");
			Match match = regex.Match(((Object)offsetBuilder).name);
			if (((Object)offsetBuilder).name == "Svarog")
			{
				HUDManager.Instance.DisplayTip("Model warning:", ((Object)offsetBuilder).name + " model has a large scale and hitbox, be careful !", 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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0020: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)player == (Object)StartOfRound.Instance.localPlayerController && !isAllowHardcore && 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_0038: 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 voiceActivate()
		{
			//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)
			{
				voiceActivate();
				return;
			}
			float num = Mathf.Clamp(Map(voice.Amplitude * sensitivity, 0f, 0.1f, 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 (interval > 5f)
			{
				interval = 0f;
				blendShapeValue = 0f;
				Mem_blendShapeValue = 0f;
				isRandomEnable = true;
				isRandomEnable_Mem = 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			float num = Vector3.Dot(Vector3.Normalize(target - ((Component)player).transform.position), ((Component)player).transform.right);
			float num2 = Vector3.Dot(Vector3.Normalize(target - ((Component)player).transform.position), ((Component)player).transform.forward);
			LimitHorizontalAngle = Mathf.Atan2(num, num2) * (180f / MathF.PI);
		}

		private void LookAtTarget(Vector3 targetPosition, bool active)
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0066: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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(LimitHorizontalAngle) <= FieldOfView)
				{
					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);
					}
				}
				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)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: 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))
			{
				return;
			}
			Transform[] bones = ((Component)nearbyPlayer).GetComponentInChildren<SkinnedMeshRenderer>().bones;
			foreach (Transform val2 in bones)
			{
				if (!(((Object)val2).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)
				{
					EyeLook_Condition = ((!player.performingEmote && !player.isSprinting) ? true : false);
					LastPosition = ((Component)nearbyPlayer).transform.position;
					if (timer != 0f)
					{
						timer = 0f;
					}
				}
				else
				{
					timer += Time.deltaTime;
					if (timer < 5f)
					{
						EyeLook_Condition = ((!player.performingEmote && !player.isSprinting) ? true : false);
					}
					else
					{
						EyeLook_Condition = false;
					}
				}
				LookAtTarget(val2.position + new Vector3(0f, 0.2f, 0f), EyeLook_Condition);
			}
		}

		private void CheckNearbyEnemy()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI[] array = Object.FindObjectsOfType<EnemyAI>();
			EnemyAI[] array2 = array;
			foreach (EnemyAI val in array2)
			{
				if (!((Object)(object)val != (Object)null) || !((Behaviour)val).isActiveAndEnabled)
				{
					continue;
				}
				float num = Vector3.Distance(((Component)player).transform.position, ((Component)val).transform.position);
				if (eyebrowIndex_fear == -1 || mouthIndex_fear == -1 || eyesIndex_fear == -1)
				{
					continue;
				}
				if (!player.isPlayerDead || !StartOfRound.Instance.shipIsLeaving)
				{
					if (num < 20f && !isEnemyNearby)
					{
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyebrowIndex_fear, 50f);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(mouthIndex_fear, 20f);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyesIndex_fear, 100f);
						if (!isEnemyNearby)
						{
							isEnemyNearby = true;
						}
					}
					else
					{
						if (!(num > 20f) || !isEnemyNearby)
						{
							continue;
						}
						if (remainingTime > 0f)
						{
							remainingTime -= Mathf.Max(Time.deltaTime, 0f);
							continue;
						}
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyebrowIndex_fear, defaultBlendValue);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(mouthIndex_fear, defaultBlendValue);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyesIndex_fear, defaultBlendValue);
						if (isEnemyNearby)
						{
							isEnemyNearby = false;
						}
						if (remainingTime != 60f)
						{
							remainingTime = 60f;
						}
					}
				}
				else
				{
					SkinnedMeshRenderer component = ((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>();
					if (component.GetBlendShapeWeight(eyebrowIndex_fear) != defaultBlendValue || component.GetBlendShapeWeight(mouthIndex_fear) != defaultBlendValue || component.GetBlendShapeWeight(eyesIndex_fear) != defaultBlendValue)
					{
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyebrowIndex_fear, defaultBlendValue);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(mouthIndex_fear, defaultBlendValue);
						((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().SetBlendShapeWeight(eyesIndex_fear, defaultBlendValue);
						isEnemyNearby = false;
						remainingTime = 60f;
					}
				}
			}
		}

		private void Awake()
		{
			if ((Object)(object)modelScript == (Object)null)
			{
				modelScript = this;
			}
			harmony.PatchAll(typeof(CharacterFeature));
		}

		private void OnEnable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0020: Expected O, but got Unknown
			if ((Object)player == (Object)StartOfRound.Instance.localPlayerController && isHelmetDisable)
			{
				((Component)player.localVisor).gameObject.SetActive(false);
			}
		}

		private void Start()
		{
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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]);
			eyebrowIndex = sharedMesh.GetBlendShapeIndex(eyebrowName[0]);
			mouthIndex_fear = ((sharedMesh.GetBlendShapeIndex(mouthName[2]) != -1) ? sharedMesh.GetBlendShapeIndex(mouthName[2]) : sharedMesh.GetBlendShapeIndex(mouthName[3]));
			eyesIndex_fear = ((sharedMesh.GetBlendShapeIndex(eyesName[3]) != -1) ? sharedMesh.GetBlendShapeIndex(eyesName[3]) : sharedMesh.GetBlendShapeIndex(eyesName[4]));
			eyebrowIndex_fear = ((sharedMesh.GetBlendShapeIndex(eyebrowName[1]) != -1) ? sharedMesh.GetBlendShapeIndex(eyebrowName[1]) : sharedMesh.GetBlendShapeIndex(eyebrowName[2]));
			MemEyesIndex = sharedMesh.GetBlendShapeIndex("Mem_eyes");
			GameObject val = new GameObject("dummyBone");
			dummyEyeBone = val.transform;
			if (GetBoneMap(((Component)this).gameObject.GetComponent<SkinnedMeshRenderer>().bones) != null && 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;
			}
		}

		private void Update()
		{
			if (!player.isPlayerDead)
			{
				ForceScaling();
				GetNearbyPlayers();
				CheckNearbyEnemy();
				ActivateMouthMovement();
			}
		}

		private void LateUpdate()
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!player.isPlayerDead)
			{
				isBlinking(!blacklist.Contains(modelName) && eyesIndex != -1);
				if (modelName == "Caelus_Remembrance" || modelName == "Stelle_Remembrance")
				{
					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 (!(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")]
		[HarmonyPostfix]
		private static void FaceEmoteOnDeath()
		{
			CharacterFeature characterFeature = Object.FindObjectOfType<CharacterFeature>();
			SkinnedMeshRenderer component = ((Component)characterFeature).gameObject.GetComponent<SkinnedMeshRenderer>();
			int blendShapeIndex = component.sharedMesh.GetBlendShapeIndex("涙");
			component.SetBlendShapeWeight(component.sharedMesh.GetBlendShapeIndex(characterFeature.mouthName[1]), 100f);
			if (characterFeature.PlayerIsDead)
			{
				return;
			}
			if (component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[1]) != -1 && component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[2]) != -1)
			{
				component.SetBlendShapeWeight((Random.Range(1, 10) % 2 == 0) ? component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[1]) : component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[2]), 100f);
				if (blendShapeIndex != -1 && component.GetBlendShapeWeight(component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[2])) >= 100f)
				{
					component.SetBlendShapeWeight(blendShapeIndex, 100f);
				}
				if (component.sharedMesh.GetBlendShapeIndex("Mem_eyes") != -1)
				{
					component.SetBlendShapeWeight(component.sharedMesh.GetBlendShapeIndex("Mem_eyes"), 100f);
				}
			}
			else if (characterFeature.eyesIndex != -1)
			{
				component.SetBlendShapeWeight(component.sharedMesh.GetBlendShapeIndex(characterFeature.eyesName[0]), 100f);
			}
			characterFeature.PlayerIsDead = true;
		}

		[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.0")]
	[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; }

		private static void InitConfig()
		{
			voiceSensitivity = config.Bind<float>("Voice sensitivity for mouth movement", "Sensitivity Value", 25f, "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");
		}

		private void Awake()
		{
			//IL_080e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0814: 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(AVENTURINE_BOSS));
			dictionary.Add("Blade_SesameCatCake", typeof(BLADE_SESAMECATCAKE));
			Dictionary<string, Type> dictionary2 = dictionary;
			foreach (KeyValuePair<string, Type> item in dictionary2)
			{
				ModelReplacementAPI.RegisterSuitModelReplacement(item.Key, item.Value);
			}
			Harmony val = new Harmony("com.zephy.lethal_starrail");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.zephy.lethal_starrail is loaded!");
		}
	}
	public static class Assets
	{
		public static string mainAssetBundleName = "LethalStarRail";

		public static AssetBundle MainAssetBundle = null;

		private static string GetAssemblyName()
		{
			return Assembly.GetExecutingAssembly().GetName().Name.Replace(" ", "_");
		}

		public static void PopulateAssets()
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetAssemblyName() + "." + mainAssetBundleName))
				{
					MainAssetBundle = AssetBundle.LoadFromStream(stream);
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}