using System;
using System.Collections;
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.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CamVisuals;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using JigglePhysics;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using Unity.Netcode;
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("sylvunnyN modelswap")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("sylvunnyN modelswap")]
[assembly: AssemblyTitle("sylvunnyN modelswap")]
[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 CamVisuals
{
	[BepInPlugin("MRCameraVisualsSylvunnyNSFW", "Sylvunny Explicit", "1.3.3")]
	public class CameraVisuals : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("CameraVisualsSylvunnyNSFW");

		private static GameObject gameObject;

		private static CameraVisuals Instance;

		public static Vector3 baseSize;

		public static ManualLogSource mls;

		private static bool usingCameraVisuals;

		private static bool terminalDisable;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = ((BaseUnityPlugin)this).Logger;
			harmony.PatchAll(typeof(CameraVisuals));
			mls.LogInfo((object)"CAMERA HEIGHTS LOADED");
		}

		public static void DetectCamera(PlayerControllerB player)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			gameObject = ((Component)player).gameObject;
			Transform val = gameObject.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer");
			if ((Object)(object)val != (Object)null)
			{
				if (Plugin.heightcompat)
				{
					Transform obj = gameObject.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer")
						.Find("MainCamera")
						.Find("HUDHelmetPosition");
					obj.localPosition += new Vector3(0f, 0.005f, 0f);
					gameObject.transform.localScale = new Vector3(1f, 1.185f, 1f);
				}
				else
				{
					mls.LogInfo((object)"Height Change was disabled. Switching to fallback.");
				}
				usingCameraVisuals = true;
			}
			else
			{
				mls.LogInfo((object)"Child GameObject not found.");
			}
		}

		public static void StopUsingModel()
		{
			usingCameraVisuals = false;
		}

		[HarmonyPatch(typeof(Terminal), "BeginUsingTerminal")]
		[HarmonyPostfix]
		public static void DetectCamera2()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			baseSize = ((Component)localPlayerController).gameObject.transform.localScale;
			if (!terminalDisable && usingCameraVisuals && Plugin.heightcompat)
			{
				Transform obj = gameObject.gameObject.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer")
					.Find("MainCamera");
				obj.localPosition += new Vector3(0f, -0.31f, -0.018f);
				terminalDisable = true;
			}
		}

		[HarmonyPatch(typeof(Terminal), "QuitTerminal")]
		[HarmonyPostfix]
		public static void ResetCamera()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (terminalDisable && usingCameraVisuals && Plugin.heightcompat)
			{
				Transform obj = gameObject.gameObject.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer")
					.Find("MainCamera");
				obj.localPosition -= new Vector3(0f, -0.31f, -0.018f);
				terminalDisable = false;
			}
		}
	}
}
namespace ModelReplacement
{
	public class MRSYLVUNNYN2 : BodyReplacementBase
	{
		[CompilerGenerated]
		private sealed class <Hurt>d__97 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MRSYLVUNNYN2 <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye1, 100f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye3, 100f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye4, 40f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye6, 100f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth1, 60f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth3, 20f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth6, 30f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth7, 60f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.cheek, 60f);
					<>2__current = (object)new WaitForSeconds(0.4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye1, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye3, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye4, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.eye6, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth1, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth3, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth6, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.mouth7, 0f);
					<>4__this.Renderers[1].SetBlendShapeWeight(<>4__this.cheek, 0f);
					Plugin.stopMouth = false;
					Plugin.stopBlink = false;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

		private PlayerControllerB player;

		private SkinnedMeshRenderer skinnedMeshRenderer0;

		private SkinnedMeshRenderer skinnedMeshRenderer1;

		private SkinnedMeshRenderer skinnedMeshRenderer2;

		private SkinnedMeshRenderer skinnedMeshRenderer3;

		private SkinnedMeshRenderer skinnedMeshRenderer5;

		private SkinnedMeshRenderer skinnedMeshRenderer6;

		private SkinnedMeshRenderer skinnedMeshRenderer7;

		private SkinnedMeshRenderer skinnedMeshRenderer8;

		private SkinnedMeshRenderer skinnedMeshRenderer9;

		private SkinnedMeshRenderer skinnedMeshRenderer11;

		private SkinnedMeshRenderer skinnedMeshRenderer12;

		private SkinnedMeshRenderer skinnedMeshRenderer14;

		private SkinnedMeshRenderer skinnedMeshRenderer15;

		private static bool usingCameraVisuals;

		private string EyeShape1 = "LowerLidRaiserL";

		private string EyeShape2 = "lowerBlinkL";

		private string EyeShape3 = "EBAllLowerL";

		private string EyeShape4 = "UpeerLidLowerL";

		private string EyeShape5 = "EBInnerLowererL";

		private string EyeShape6 = "EBOuterLowererL";

		private string CheekShape = "CheekRaiser1L";

		private string MouthShape1 = "UppeLipRaiser";

		private string MouthShape2 = "SmirkL";

		private string MouthShape3 = "CornerLowerL";

		private string MouthShape4 = "LowerLipLower";

		private string MouthShape5 = "MouthOpenL";

		private string MouthShape6 = "StrecherL";

		private string MouthShape7 = "bite1L";

		private int eye1;

		private int eye2;

		private int eye3;

		private int eye4;

		private int eye5;

		private int eye6;

		private int cheek;

		private int mouth1;

		private int mouth2;

		private int mouth3;

		private int mouth4;

		private int mouth5;

		private int mouth6;

		private int mouth7;

		private string fitShapeName = "fit";

		private string armShapeName = "ArmsMuscles";

		private string breastShapeName1 = "Breastsize";

		private string breastShapeName2 = "Breastflatten";

		private string breastShapeName3 = "BreastSmall";

		private string breastShapeName4 = "BreastsizeSUIT";

		private string breastShapeName5 = "BreastNnipplePerk";

		private string buttShapeName = "Buttsize";

		private string hipsShapeName = "widehips";

		private string legsShapeName = "Legsize";

		private string bellyShapeName = "Pregnant";

		private string waistShapeName = "waist1";

		private string slimShapeName = "slim";

		private string canonShapeName = "cannonSlim2";

		private string fluffShapeName = "flufback";

		private int fit;

		private int arm;

		private int breast1;

		private int breast2;

		private int breast3;

		private int breast4;

		private int breast5;

		private int butt;

		private int hips;

		private int legs;

		private int belly;

		private int waist;

		private int slim;

		private int canon;

		private int fluff;

		private float fitValue = Plugin.fitModifier.Value;

		private float armValue = Plugin.armMuscleModifier.Value;

		private float breastValue = Plugin.breastModifier.Value;

		private float nippleValue = Plugin.nippleModifier.Value;

		private float buttValue = Plugin.buttModifier.Value;

		private float hipValue = Plugin.hipsModifier.Value;

		private float legValue = Plugin.legsModifier.Value;

		private float bellyValue = Plugin.bellyModifier.Value;

		private float waistValue = Plugin.waistModifier.Value;

		private float slimValue = Plugin.slimModifier.Value;

		private float canonValue = Plugin.canonModifier.Value;

		private float fluffValue = Plugin.fluffModifier.Value;

		private SkinnedMeshRenderer[] Renderers;

		private SkinnedMeshRenderer[] deadRenderers;

		private SkinnedMeshRenderer[] viewModelRenderers;

		private JiggleRigBuilder[] jiggleBones;

		protected override GameObject LoadAssetsAndReturnModel()
		{
			string text = "sylvunnyN2";
			return Assets.MainAssetBundle.LoadAsset<GameObject>(text);
		}

		protected override void Start()
		{
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			((BodyReplacementBase)this).Start();
			player = ((BodyReplacementBase)this).controller;
			GameObject gameObject = ((Component)base.replacementModel.transform.Find("belly cover")).gameObject;
			GameObject gameObject2 = ((Component)base.replacementModel.transform.Find("Body.dmx")).gameObject;
			GameObject gameObject3 = ((Component)base.replacementModel.transform.Find("buttons")).gameObject;
			GameObject gameObject4 = ((Component)base.replacementModel.transform.Find("cap")).gameObject;
			GameObject gameObject5 = ((Component)base.replacementModel.transform.Find("hand supportE")).gameObject;
			GameObject gameObject6 = ((Component)base.replacementModel.transform.Find("jacket")).gameObject;
			GameObject gameObject7 = ((Component)base.replacementModel.transform.Find("leggins.dmx")).gameObject;
			GameObject gameObject8 = ((Component)base.replacementModel.transform.Find("niptape")).gameObject;
			GameObject gameObject9 = ((Component)base.replacementModel.transform.Find("pussytape")).gameObject;
			GameObject gameObject10 = ((Component)base.replacementModel.transform.Find("Skirt")).gameObject;
			GameObject gameObject11 = ((Component)base.replacementModel.transform.Find("suit1.dmx")).gameObject;
			GameObject gameObject12 = ((Component)base.replacementModel.transform.Find("Top")).gameObject;
			GameObject gameObject13 = ((Component)base.replacementModel.transform.Find("top")).gameObject;
			if ((Object)(object)skinnedMeshRenderer0 == (Object)null)
			{
				skinnedMeshRenderer0 = gameObject.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer1 == (Object)null)
			{
				skinnedMeshRenderer1 = gameObject2.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer2 == (Object)null)
			{
				skinnedMeshRenderer2 = gameObject3.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer3 == (Object)null)
			{
				skinnedMeshRenderer3 = gameObject4.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer5 == (Object)null)
			{
				skinnedMeshRenderer5 = gameObject5.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer6 == (Object)null)
			{
				skinnedMeshRenderer6 = gameObject6.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer7 == (Object)null)
			{
				skinnedMeshRenderer7 = gameObject7.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer8 == (Object)null)
			{
				skinnedMeshRenderer8 = gameObject8.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer9 == (Object)null)
			{
				skinnedMeshRenderer9 = gameObject9.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer11 == (Object)null)
			{
				skinnedMeshRenderer11 = gameObject10.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer12 == (Object)null)
			{
				skinnedMeshRenderer12 = gameObject11.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer14 == (Object)null)
			{
				skinnedMeshRenderer14 = gameObject12.GetComponent<SkinnedMeshRenderer>();
			}
			if ((Object)(object)skinnedMeshRenderer15 == (Object)null)
			{
				skinnedMeshRenderer15 = gameObject13.GetComponent<SkinnedMeshRenderer>();
			}
			GameObject gameObject14 = ((Component)player).gameObject;
			Transform val = gameObject14.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer");
			if ((Object)(object)val != (Object)null)
			{
				GameObject gameObject15 = ((Component)val).gameObject;
				if (!usingCameraVisuals)
				{
					usingCameraVisuals = true;
					Task.Delay(50).ContinueWith(delegate
					{
						CameraVisuals.DetectCamera(player);
					});
					if (!Plugin.heightcompat)
					{
						Transform transform = base.replacementModel.transform;
						transform.localPosition += new Vector3(0f, 0.31f, 0f);
					}
				}
			}
			else
			{
				CameraVisuals.mls.LogInfo((object)"Child GameObject not found.");
			}
			Plugin.usingModel = true;
			Plugin.stopBlink = false;
			Plugin.stopMouth = false;
			Renderers = base.replacementModel.GetComponentsInChildren<SkinnedMeshRenderer>();
			jiggleBones = base.replacementModel.GetComponentsInChildren<JiggleRigBuilder>();
			if (ModelReplacementAPI.EnforceViewModelGeneration.Value)
			{
				viewModelRenderers = base.replacementViewModel.GetComponentsInChildren<SkinnedMeshRenderer>();
			}
			fitValue = Mathf.Clamp(fitValue, 0f, 100f);
			armValue = Mathf.Clamp(armValue, 0f, 100f);
			breastValue = Mathf.Clamp(breastValue, -100f, 200f);
			nippleValue = Mathf.Clamp(nippleValue, 0f, 100f);
			buttValue = Mathf.Clamp(buttValue, 0f, 100f);
			hipValue = Mathf.Clamp(hipValue, 0f, 100f);
			legValue = Mathf.Clamp(legValue, 0f, 100f);
			bellyValue = Mathf.Clamp(bellyValue, 0f, 100f);
			waistValue = Mathf.Clamp(waistValue, 0f, 100f);
			slimValue = Mathf.Clamp(slimValue, 0f, 100f);
			canonValue = Mathf.Clamp(canonValue, 0f, 100f);
			fluffValue = Mathf.Clamp(fluffValue, 0f, 100f);
			eye1 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape1);
			eye2 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape2);
			eye3 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape3);
			eye4 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape4);
			eye5 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape5);
			eye6 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(EyeShape6);
			cheek = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(CheekShape);
			mouth1 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape1);
			mouth2 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape2);
			mouth3 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape3);
			mouth4 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape4);
			mouth5 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape5);
			mouth6 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape6);
			mouth7 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(MouthShape7);
			fit = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(fitShapeName);
			arm = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(armShapeName);
			breast1 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(breastShapeName1);
			breast2 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(breastShapeName2);
			breast3 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(breastShapeName3);
			breast4 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(breastShapeName4);
			breast5 = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(breastShapeName5);
			butt = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(buttShapeName);
			hips = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(hipsShapeName);
			legs = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(legsShapeName);
			belly = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(bellyShapeName);
			waist = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(waistShapeName);
			slim = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(slimShapeName);
			canon = skinnedMeshRenderer1.sharedMesh.GetBlendShapeIndex(canonShapeName);
			fluff = skinnedMeshRenderer5.sharedMesh.GetBlendShapeIndex(fluffShapeName);
			if (!Plugin.TMEPatch)
			{
				Renderers[1].SetBlendShapeWeight(eye1, 0f);
				Renderers[1].SetBlendShapeWeight(eye2, 0f);
				Renderers[1].SetBlendShapeWeight(eye3, 0f);
				Renderers[1].SetBlendShapeWeight(eye4, 0f);
				Renderers[1].SetBlendShapeWeight(eye5, 0f);
				Renderers[1].SetBlendShapeWeight(eye6, 0f);
				Renderers[1].SetBlendShapeWeight(cheek, 0f);
				Renderers[1].SetBlendShapeWeight(mouth1, 0f);
				Renderers[1].SetBlendShapeWeight(mouth2, 0f);
				Renderers[1].SetBlendShapeWeight(mouth3, 0f);
				Renderers[1].SetBlendShapeWeight(mouth4, 0f);
				Renderers[1].SetBlendShapeWeight(mouth5, 0f);
				Renderers[1].SetBlendShapeWeight(mouth6, 0f);
				Renderers[1].SetBlendShapeWeight(mouth7, 0f);
			}
			Renderers[1].SetBlendShapeWeight(fit, fitValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			Renderers[1].SetBlendShapeWeight(arm, armValue);
			Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			Renderers[1].SetBlendShapeWeight(breast5, nippleValue);
			Renderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			Renderers[1].SetBlendShapeWeight(butt, buttValue);
			Renderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			Renderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			Renderers[1].SetBlendShapeWeight(hips, hipValue);
			Renderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			Renderers[1].SetBlendShapeWeight(legs, legValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			Renderers[1].SetBlendShapeWeight(belly, bellyValue);
			Renderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			Renderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex("Bulge1"), bellyValue / 3f);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			Renderers[1].SetBlendShapeWeight(waist, waistValue);
			Renderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			Renderers[1].SetBlendShapeWeight(slim, slimValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			Renderers[1].SetBlendShapeWeight(canon, canonValue);
			Renderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			Renderers[5].SetBlendShapeWeight(fluff, fluffValue);
			if (ModelReplacementAPI.EnforceViewModelGeneration.Value)
			{
				viewModelRenderers[5].SetBlendShapeWeight(fluff, fluffValue);
			}
			if (breastValue >= 0f)
			{
				float num = Mathf.Clamp(breastValue, 0f, 100f);
				Renderers[1].SetBlendShapeWeight(breast1, num);
				Renderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				if (breastValue > 100f)
				{
					Renderers[1].SetBlendShapeWeight(breast4, breastValue - 100f);
				}
			}
			else if (breastValue < 0f)
			{
				Renderers[1].SetBlendShapeWeight(breast2, 0f - breastValue);
				Renderers[1].SetBlendShapeWeight(breast3, 0f - breastValue * 0.4f);
				Renderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				Renderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName3), 0f - breastValue * 0.4f);
				Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				Renderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName3), 0f - breastValue * 0.4f);
				Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				Renderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName3), 0f - breastValue * 0.4f);
				Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				Renderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName3), 0f - breastValue * 0.4f);
				Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				Renderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName3), 0f - breastValue * 0.4f);
				if (breastValue <= -70f)
				{
					((Behaviour)jiggleBones[7]).enabled = false;
					((Behaviour)jiggleBones[8]).enabled = false;
				}
				else
				{
					((Behaviour)jiggleBones[7]).enabled = true;
					((Behaviour)jiggleBones[8]).enabled = true;
				}
			}
			if (breastValue <= 100f)
			{
				Renderers[1].SetBlendShapeWeight(breast4, 0f);
			}
			((Renderer)Renderers[0]).enabled = false;
			((Renderer)Renderers[2]).enabled = false;
			((Renderer)Renderers[3]).enabled = false;
			((Renderer)Renderers[6]).enabled = false;
			((Renderer)Renderers[7]).enabled = false;
			((Renderer)Renderers[8]).enabled = false;
			((Renderer)Renderers[9]).enabled = false;
			((Renderer)Renderers[11]).enabled = false;
			((Renderer)Renderers[12]).enabled = false;
			((Renderer)Renderers[14]).enabled = false;
			((Renderer)Renderers[15]).enabled = false;
			if (Plugin.fluffEnable.Value)
			{
				((Renderer)Renderers[5]).enabled = true;
				if (ModelReplacementAPI.EnforceViewModelGeneration.Value)
				{
					((Renderer)viewModelRenderers[5]).enabled = true;
				}
			}
			else if (!Plugin.fluffEnable.Value)
			{
				((Renderer)Renderers[5]).enabled = false;
				if (ModelReplacementAPI.EnforceViewModelGeneration.Value)
				{
					((Renderer)viewModelRenderers[5]).enabled = false;
				}
			}
			if (Plugin.schoolTopEnable.Value)
			{
				((Renderer)Renderers[14]).enabled = true;
				((Renderer)Renderers[2]).enabled = true;
			}
			if (Plugin.schoolSkirtEnable.Value)
			{
				((Renderer)Renderers[11]).enabled = true;
			}
			if (Plugin.bunnyEnable.Value)
			{
				((Renderer)Renderers[12]).enabled = true;
			}
			if (Plugin.capEnable.Value)
			{
				((Renderer)Renderers[3]).enabled = true;
			}
			if (Plugin.megaTopEnable.Value)
			{
				((Renderer)Renderers[15]).enabled = true;
			}
			if (Plugin.megaLegsEnable.Value)
			{
				((Renderer)Renderers[7]).enabled = true;
			}
			if (Plugin.bellyCoverEnable.Value)
			{
				((Renderer)Renderers[0]).enabled = true;
			}
			if (Plugin.jacketEnable.Value)
			{
				((Renderer)Renderers[6]).enabled = true;
			}
			if (Plugin.nipTapeEnable.Value)
			{
				((Renderer)Renderers[8]).enabled = true;
			}
			if (Plugin.crotchTapeEnable.Value)
			{
				((Renderer)Renderers[9]).enabled = true;
			}
			if (Plugin.EmoteAudio.Value)
			{
				AudioClip randomAudio = Assets.SSpawn.GetRandomAudio(StartOfRound.Instance.randomMapSeed);
				((BodyReplacementBase)this).controller.movementAudio.PlayOneShot(randomAudio, 0.4f);
			}
			((BodyReplacementBase)this).Start();
		}

		protected override void OnDamageTaken(bool dead)
		{
			((BodyReplacementBase)this).OnDamageTaken(dead);
			if (!Plugin.TMEPatch)
			{
				Plugin.stopMouth = true;
				Plugin.stopBlink = true;
				((MonoBehaviour)this).StartCoroutine(Hurt());
			}
			if (Plugin.EmoteAudio.Value)
			{
				AudioClip randomAudio = Assets.SHurt.GetRandomAudio(StartOfRound.Instance.randomMapSeed);
				((BodyReplacementBase)this).controller.movementAudio.PlayOneShot(randomAudio, 0.9f);
			}
		}

		protected override void OnDeath()
		{
			((BodyReplacementBase)this).OnDeath();
			Plugin.stopMouth = true;
			Plugin.stopBlink = true;
			GameObject gameObject = ((Component)player).gameObject;
			deadRenderers = ((BodyReplacementBase)gameObject.GetComponent<MRSYLVUNNYN2>()).replacementDeadBody.GetComponentsInChildren<SkinnedMeshRenderer>();
			if (!Plugin.TMEPatch)
			{
				deadRenderers[1].SetBlendShapeWeight(eye2, 100f);
				deadRenderers[1].SetBlendShapeWeight(eye3, 100f);
				deadRenderers[1].SetBlendShapeWeight(mouth3, 70f);
				deadRenderers[1].SetBlendShapeWeight(mouth5, 35f);
				deadRenderers[1].SetBlendShapeWeight(eye1, 0f);
				deadRenderers[1].SetBlendShapeWeight(eye4, 0f);
				deadRenderers[1].SetBlendShapeWeight(eye5, 0f);
				deadRenderers[1].SetBlendShapeWeight(eye6, 0f);
				deadRenderers[1].SetBlendShapeWeight(cheek, 0f);
				deadRenderers[1].SetBlendShapeWeight(mouth1, 0f);
				deadRenderers[1].SetBlendShapeWeight(mouth2, 0f);
				deadRenderers[1].SetBlendShapeWeight(mouth4, 0f);
				deadRenderers[1].SetBlendShapeWeight(mouth6, 0f);
				deadRenderers[1].SetBlendShapeWeight(mouth7, 0f);
			}
			if ((Object)(object)base.replacementDeadBody.GetComponent<AudioSource>() == (Object)null)
			{
				base.replacementDeadBody.AddComponent<AudioSource>();
			}
			if (Plugin.EmoteAudio.Value)
			{
				AudioClip randomAudio = Assets.SDie.GetRandomAudio(StartOfRound.Instance.randomMapSeed);
				AudioSource component = base.replacementDeadBody.GetComponent<AudioSource>();
				component.PlayOneShot(randomAudio, 0.5f);
			}
			deadRenderers[1].SetBlendShapeWeight(fit, fitValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(fitShapeName), fitValue);
			deadRenderers[1].SetBlendShapeWeight(arm, armValue);
			deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(armShapeName), armValue);
			deadRenderers[1].SetBlendShapeWeight(breast5, nippleValue);
			deadRenderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName5), nippleValue);
			deadRenderers[1].SetBlendShapeWeight(butt, buttValue);
			deadRenderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			deadRenderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(buttShapeName), buttValue);
			deadRenderers[1].SetBlendShapeWeight(hips, hipValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(hipsShapeName), hipValue);
			deadRenderers[1].SetBlendShapeWeight(legs, legValue);
			deadRenderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(legsShapeName), legValue);
			deadRenderers[1].SetBlendShapeWeight(belly, bellyValue);
			deadRenderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			deadRenderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex("Bulge1"), bellyValue / 3f);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(bellyShapeName), bellyValue);
			deadRenderers[1].SetBlendShapeWeight(waist, waistValue);
			deadRenderers[0].SetBlendShapeWeight(skinnedMeshRenderer0.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(waistShapeName), waistValue);
			deadRenderers[1].SetBlendShapeWeight(slim, slimValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(slimShapeName), slimValue);
			deadRenderers[1].SetBlendShapeWeight(canon, canonValue);
			deadRenderers[7].SetBlendShapeWeight(skinnedMeshRenderer7.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[9].SetBlendShapeWeight(skinnedMeshRenderer9.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[11].SetBlendShapeWeight(skinnedMeshRenderer11.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(canonShapeName), canonValue);
			if (breastValue >= 0f)
			{
				float num = Mathf.Clamp(breastValue, 0f, 100f);
				deadRenderers[1].SetBlendShapeWeight(breast1, num);
				deadRenderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName1), num);
				if (breastValue > 100f)
				{
					deadRenderers[1].SetBlendShapeWeight(breast4, breastValue - 100f);
				}
			}
			else if (breastValue < 0f)
			{
				deadRenderers[1].SetBlendShapeWeight(breast2, 0f - breastValue);
				deadRenderers[6].SetBlendShapeWeight(skinnedMeshRenderer6.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				deadRenderers[8].SetBlendShapeWeight(skinnedMeshRenderer8.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				deadRenderers[12].SetBlendShapeWeight(skinnedMeshRenderer12.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				deadRenderers[14].SetBlendShapeWeight(skinnedMeshRenderer14.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				deadRenderers[15].SetBlendShapeWeight(skinnedMeshRenderer15.sharedMesh.GetBlendShapeIndex(breastShapeName2), 0f - breastValue);
				deadRenderers[1].SetBlendShapeWeight(breast3, 0f - breastValue * 0.4f);
			}
			if (breastValue <= 100f)
			{
				deadRenderers[1].SetBlendShapeWeight(breast4, 0f);
			}
			((Renderer)deadRenderers[1]).forceRenderingOff = true;
			((Renderer)deadRenderers[2]).forceRenderingOff = true;
			((Renderer)deadRenderers[3]).forceRenderingOff = true;
			((Renderer)deadRenderers[5]).forceRenderingOff = true;
			((Renderer)deadRenderers[6]).forceRenderingOff = true;
			((Renderer)deadRenderers[7]).forceRenderingOff = true;
			((Renderer)deadRenderers[8]).forceRenderingOff = true;
			((Renderer)deadRenderers[9]).forceRenderingOff = true;
			((Renderer)deadRenderers[11]).forceRenderingOff = true;
			((Renderer)deadRenderers[12]).forceRenderingOff = true;
			((Renderer)deadRenderers[14]).forceRenderingOff = true;
			((Renderer)deadRenderers[15]).forceRenderingOff = true;
			if (Plugin.fluffEnable.Value)
			{
				((Renderer)deadRenderers[5]).forceRenderingOff = false;
			}
			if (Plugin.schoolTopEnable.Value)
			{
				((Renderer)deadRenderers[14]).forceRenderingOff = false;
				((Renderer)deadRenderers[2]).forceRenderingOff = false;
			}
			if (Plugin.schoolSkirtEnable.Value)
			{
				((Renderer)deadRenderers[11]).forceRenderingOff = false;
			}
			if (Plugin.bunnyEnable.Value)
			{
				((Renderer)deadRenderers[12]).forceRenderingOff = false;
			}
			if (Plugin.capEnable.Value)
			{
				((Renderer)deadRenderers[3]).forceRenderingOff = false;
			}
			if (Plugin.megaTopEnable.Value)
			{
				((Renderer)deadRenderers[15]).forceRenderingOff = false;
			}
			if (Plugin.megaLegsEnable.Value)
			{
				((Renderer)deadRenderers[7]).forceRenderingOff = false;
			}
			if (Plugin.bellyCoverEnable.Value)
			{
				((Renderer)deadRenderers[0]).forceRenderingOff = false;
			}
			if (Plugin.jacketEnable.Value)
			{
				((Renderer)deadRenderers[6]).forceRenderingOff = false;
			}
			if (Plugin.nipTapeEnable.Value)
			{
				((Renderer)deadRenderers[8]).forceRenderingOff = false;
			}
			if (Plugin.crotchTapeEnable.Value)
			{
				((Renderer)deadRenderers[9]).forceRenderingOff = false;
			}
		}

		protected override void AddModelScripts()
		{
			((BodyReplacementBase)this).AddModelScripts();
			GameObject gameObject = ((Component)base.replacementModel.transform.Find("Body.dmx")).gameObject;
			Blinking blinking = gameObject.AddComponent(typeof(Blinking)) as Blinking;
			blinking.player = ((BodyReplacementBase)this).controller;
			JawSync jawSync = gameObject.AddComponent(typeof(JawSync)) as JawSync;
			jawSync.player = ((BodyReplacementBase)this).controller;
			jawSync.init();
		}

		protected override void OnEmoteStart(int emoteId)
		{
			((BodyReplacementBase)this).OnEmoteStart(emoteId);
			switch (emoteId)
			{
			case 1:
				if (!Plugin.TMEPatch)
				{
					Plugin.stopMouth = true;
					Plugin.stopBlink = true;
					Renderers[1].SetBlendShapeWeight(eye1, 100f);
					Renderers[1].SetBlendShapeWeight(cheek, 60f);
					Renderers[1].SetBlendShapeWeight(mouth1, 60f);
					Renderers[1].SetBlendShapeWeight(mouth2, 70f);
					Renderers[1].SetBlendShapeWeight(mouth4, 40f);
					Renderers[1].SetBlendShapeWeight(eye3, 0f);
					Renderers[1].SetBlendShapeWeight(eye4, 0f);
					Renderers[1].SetBlendShapeWeight(eye5, 0f);
					Renderers[1].SetBlendShapeWeight(mouth5, 0f);
					if (Plugin.EmoteAudio.Value)
					{
						AudioClip randomAudio2 = Assets.SDance.GetRandomAudio(StartOfRound.Instance.randomMapSeed);
						((BodyReplacementBase)this).controller.movementAudio.PlayOneShot(randomAudio2, 0.5f);
					}
				}
				break;
			case 2:
				if (!Plugin.TMEPatch)
				{
					Plugin.stopMouth = true;
					Plugin.stopBlink = true;
					Renderers[1].SetBlendShapeWeight(eye3, 100f);
					Renderers[1].SetBlendShapeWeight(eye4, 40f);
					Renderers[1].SetBlendShapeWeight(eye5, 100f);
					Renderers[1].SetBlendShapeWeight(mouth1, 50f);
					Renderers[1].SetBlendShapeWeight(mouth5, 70f);
					Renderers[1].SetBlendShapeWeight(eye1, 0f);
					Renderers[1].SetBlendShapeWeight(cheek, 0f);
					Renderers[1].SetBlendShapeWeight(mouth2, 0f);
					Renderers[1].SetBlendShapeWeight(mouth4, 0f);
					if (Plugin.EmoteAudio.Value)
					{
						AudioClip randomAudio = Assets.SPoint.GetRandomAudio(StartOfRound.Instance.randomMapSeed);
						((BodyReplacementBase)this).controller.movementAudio.PlayOneShot(randomAudio, 0.5f);
					}
				}
				break;
			}
		}

		protected override void OnEmoteEnd()
		{
			((BodyReplacementBase)this).OnEmoteEnd();
			if (!Plugin.TMEPatch)
			{
				Renderers[1].SetBlendShapeWeight(eye1, 0f);
				Renderers[1].SetBlendShapeWeight(eye3, 0f);
				Renderers[1].SetBlendShapeWeight(eye4, 0f);
				Renderers[1].SetBlendShapeWeight(eye5, 0f);
				Renderers[1].SetBlendShapeWeight(cheek, 0f);
				Renderers[1].SetBlendShapeWeight(mouth1, 0f);
				Renderers[1].SetBlendShapeWeight(mouth2, 0f);
				Renderers[1].SetBlendShapeWeight(mouth4, 0f);
				Renderers[1].SetBlendShapeWeight(mouth5, 0f);
				Plugin.stopMouth = false;
				Plugin.stopBlink = false;
			}
		}

		protected override void OnDestroy()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)player).gameObject;
			if (usingCameraVisuals)
			{
				Plugin.usingModel = false;
				CameraVisuals.StopUsingModel();
				gameObject.transform.Find("ScavengerModel").Find("metarig").Find("CameraContainer")
					.Find("MainCamera")
					.Find("HUDHelmetPosition")
					.localPosition = new Vector3(0.01f, -0.048f, -0.063f);
				gameObject.transform.localScale = new Vector3(1f, 1f, 1f);
				usingCameraVisuals = false;
			}
			((BodyReplacementBase)this).OnDestroy();
		}

		[IteratorStateMachine(typeof(<Hurt>d__97))]
		private IEnumerator Hurt()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Hurt>d__97(0)
			{
				<>4__this = this
			};
		}
	}
	public class Blinking : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DoBlink>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Blinking <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.isBlinking = true;
					goto IL_00ed;
				case 1:
					<>1__state = -1;
					goto IL_00ed;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_00ed:
					if (<>4__this.blinkWeight < 100f && !Plugin.stopBlink)
					{
						<>4__this.blinkWeight += <>4__this.blinkSpeed * Time.deltaTime;
						<>4__this.blinkWeight = Mathf.Clamp(<>4__this.blinkWeight, 0f, 100f);
						<>4__this.skinnedMeshRenderer.SetBlendShapeWeight(<>4__this.skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(<>4__this.blendShapeName), <>4__this.blinkWeight);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(0.04f);
					<>1__state = 2;
					return true;
				}
				if (<>4__this.blinkWeight > 0f && !Plugin.stopBlink)
				{
					<>4__this.blinkWeight -= <>4__this.blinkSpeed * Time.deltaTime;
					<>4__this.blinkWeight = Mathf.Clamp(<>4__this.blinkWeight, 0f, 100f);
					<>4__this.skinnedMeshRenderer.SetBlendShapeWeight(<>4__this.skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(<>4__this.blendShapeName), <>4__this.blinkWeight);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				<>4__this.isBlinking = false;
				<>4__this.nextBlinkTime = Time.time + Random.Range(<>4__this.minBlinkInterval, <>4__this.maxBlinkInterval);
				return false;
			}

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

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

		public PlayerControllerB player;

		private SkinnedMeshRenderer skinnedMeshRenderer;

		private string blendShapeName = "Blink1L";

		private float minBlinkInterval = 5f;

		private float maxBlinkInterval = 8f;

		private float blinkSpeed = 1100f;

		private float nextBlinkTime;

		private bool isBlinking = false;

		private float blinkWeight = 0f;

		private void Start()
		{
			if ((Object)(object)skinnedMeshRenderer == (Object)null)
			{
				skinnedMeshRenderer = ((Component)this).GetComponent<SkinnedMeshRenderer>();
			}
			skinnedMeshRenderer.SetBlendShapeWeight(skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(blendShapeName), 0f);
			nextBlinkTime = Time.time + Random.Range(minBlinkInterval, maxBlinkInterval);
		}

		private void Update()
		{
			if (!player.isPlayerDead && Time.time >= nextBlinkTime && !isBlinking)
			{
				((MonoBehaviour)this).StartCoroutine(DoBlink());
			}
		}

		[IteratorStateMachine(typeof(<DoBlink>d__11))]
		private IEnumerator DoBlink()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoBlink>d__11(0)
			{
				<>4__this = this
			};
		}
	}
	public class JawSync : MonoBehaviour
	{
		public PlayerControllerB player;

		private float maxOpen1 = 49f;

		private float maxOpen2 = 64f;

		private float maxOpen3 = 68f;

		private SkinnedMeshRenderer skinnedMeshRenderer;

		private float sensibility = 100f * Plugin.voiceSensitivity.Value;

		protected VoicePlayerState voice;

		private string blendShapeName1 = "StrecherL";

		private string blendShapeName2 = "SmirkL";

		private string blendShapeName3 = "MouthOpenL";

		public void Start()
		{
			if ((Object)(object)skinnedMeshRenderer == (Object)null)
			{
				skinnedMeshRenderer = ((Component)this).GetComponent<SkinnedMeshRenderer>();
			}
		}

		private void Update()
		{
			if ((Object)(object)StartOfRound.Instance.voiceChatModule == (Object)null)
			{
				return;
			}
			if (voice == null)
			{
				init();
			}
			if (voice != null && !Plugin.stopMouth)
			{
				float num = 0f;
				float num2 = 0f;
				float num3 = 0f;
				if (voice.IsSpeaking)
				{
					num = (player.isPlayerDead ? 0f : Mathf.Clamp(voice.Amplitude * sensibility, 0f, maxOpen1));
					num2 = (player.isPlayerDead ? 0f : Mathf.Clamp(voice.Amplitude * sensibility, 0f, maxOpen2));
					num3 = (player.isPlayerDead ? 0f : Mathf.Clamp(voice.Amplitude * sensibility, 0f, maxOpen3));
				}
				skinnedMeshRenderer.SetBlendShapeWeight(skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(blendShapeName1), num);
				skinnedMeshRenderer.SetBlendShapeWeight(skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(blendShapeName2), num2);
				skinnedMeshRenderer.SetBlendShapeWeight(skinnedMeshRenderer.sharedMesh.GetBlendShapeIndex(blendShapeName3), num3);
			}
		}

		public void init()
		{
			StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
			voice = player.voicePlayerState;
			if (voice == null && (Object)(object)player == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				voice = StartOfRound.Instance.voiceChatModule.FindPlayer(StartOfRound.Instance.voiceChatModule.LocalPlayerName);
			}
		}
	}
	[BepInPlugin("com.wintermantis.sylvunnyNSFW", "sylvunnyNSFW", "1.3.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static string PLUGIN_GUID = "com.wintermantis.sylvunnyNSFW";

		public static string PLUGIN_VERSION = "1.3.3";

		public static bool TMEPatch;

		public static bool usingModel;

		public static bool stopBlink;

		public static bool stopMouth;

		public static bool heightcompat;

		public static ConfigFile config;

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

		public static ConfigEntry<string> suitNamesToEnableModel { get; private set; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		private static void InitConfig()
		{
			voiceSensitivity = config.Bind<float>("Voice Sensitivity", "Sensitivity Value", 10f, "Sensitivity of Sylvunny's Jaw. Number from 5 to 20");
			suitNamesToEnableModel = config.Bind<string>("Suits to Replace Settings", "Suits to enable Model for", "Sylvunny (NSFW)", "Enter a comma separated list of suit names.(Additionally, [Green suit,Pajama suit,Hazard suit])");
			enableHeight = config.Bind<bool>("Misc", "Enable Height Change", true, "Enable the Camera Visual code for this suit. You will not be able to use this in lobbies without this suit installed! Requires restart.");
			EmoteAudio = config.Bind<bool>("Misc", "Enable emote audio clips", true, "Plays audio when performing vanilla emotes or when taking damage. Will only work on emotes if the TME Patch is disabled.");
			fitModifier = config.Bind<float>("Body", "Fitness Modifier", 0f, "Modifier of Sylvunny's fitness. Number from 0 to 100.");
			armMuscleModifier = config.Bind<float>("Body", "Arm Muscle Modifier", 0f, "Modifier of Sylvunny's muscles. Number from 0 to 100.");
			breastModifier = config.Bind<float>("Body", "Breast Modifier", 0f, "Modifier of Sylvunny's breast size. Number from -100 to 200.");
			nippleModifier = config.Bind<float>("Body", "Nipple Perk Modifier", 0f, "Modifier of Sylvunny's nipple size. Number from 0 to 100.");
			buttModifier = config.Bind<float>("Body", "Butt Modifier", 0f, "Modifier of Sylvunny's butt size. Number from 0 to 100.");
			hipsModifier = config.Bind<float>("Body", "Hips Modifier", 0f, "Modifier of Sylvunny's hip size. Number from 0 to 100.");
			legsModifier = config.Bind<float>("Body", "Legs Modifier", 0f, "Modifier of Sylvunny's leg size. Number from 0 to 100.");
			bellyModifier = config.Bind<float>("Body", "Belly Modifier", 0f, "Modifier of Sylvunny's belly size. Number from 0 to 100.");
			waistModifier = config.Bind<float>("Body", "Waist Modifier", 0f, "Modifier of Sylvunny's waist size. Number from 0 to 100.");
			slimModifier = config.Bind<float>("Body", "Slim Modifier", 0f, "Modifier of Sylvunny's slimness. Number from 0 to 100.");
			canonModifier = config.Bind<float>("Body", "Canon Slim Modifier", 0f, "Modifier to make Sylvunny more accurate to original Lopunny. Number from 0 to 100. Recommended that every other torso blendshape is set to 0 while using this.");
			fluffModifier = config.Bind<float>("Body", "Wrist Fluff Modifier", 0f, "Modifier of Sylvunny's wrist fluff. Number from 0 to 100.");
			fluffEnable = config.Bind<bool>("Body", "Wrist Fluff Enabler", true, "Enable Sylvunny's wrist fluff.");
			schoolTopEnable = config.Bind<bool>("Clothes", "School Top Enabler", true, "Enable Sylvunny's school shirt.");
			schoolSkirtEnable = config.Bind<bool>("Clothes", "School Skirt Enabler", true, "Enable Sylvunny's school skirt.");
			bunnyEnable = config.Bind<bool>("Clothes", "Bunnysuit Enabler", false, "Enable Sylvunny's bunnysuit.");
			capEnable = config.Bind<bool>("Clothes", "Bunnysuit Cap Enabler", false, "Enable Sylvunny's bunnysuit cap.");
			megaTopEnable = config.Bind<bool>("Clothes", "Mega Top Enabler", false, "Enable Sylvunny's Mega Evolution top.");
			megaLegsEnable = config.Bind<bool>("Clothes", "Mega Legs Enabler", false, "Enable Sylvunny's Mega Evolution leggings.");
			bellyCoverEnable = config.Bind<bool>("Clothes", "Belly Cover Enabler", false, "Enable Sylvunny's belly cover.");
			jacketEnable = config.Bind<bool>("Clothes", "Jacket Enabler", false, "Enable Sylvunny's jacket.");
			nipTapeEnable = config.Bind<bool>("Clothes", "Nipple Tape Enabler", false, "Enable Sylvunny's Nipple Tape.");
			crotchTapeEnable = config.Bind<bool>("Clothes", "Crotch Tape Enabler", false, "Enable Sylvunny's crotch tape.");
		}

		private void Awake()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			config = ((BaseUnityPlugin)this).Config;
			InitConfig();
			Assets.PopulateAssets();
			string[] array = suitNamesToEnableModel.Value.Split(',');
			string[] array2 = array;
			string[] array3 = array2;
			foreach (string text in array3)
			{
				ModelReplacementAPI.RegisterSuitModelReplacement(text, typeof(MRSYLVUNNYN2));
			}
			if (ModelReplacementAPI.tooManyEmotesPresent)
			{
				TMEPatch = true;
				((BaseUnityPlugin)this).Logger.LogWarning((object)"TooManyEmotes was found, automatically applying compatibility patch.");
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"TooManyEmotes not found, disabling compatibility patch.");
				TMEPatch = false;
			}
			heightcompat = enableHeight.Value;
			if (heightcompat)
			{
				NetworkPrefab val = new NetworkPrefab();
				if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"LobbyCompatibility detected! Creating compat information...");
					LobbyCompatibility.Init(0);
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Height change enabled, loading in server-side compatibility.");
				}
			}
			else if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"LobbyCompatibility detected! Creating compat information...");
				LobbyCompatibility.Init(1);
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Height change disabled, loading in client-side compatibility.");
			}
			Harmony val2 = new Harmony(PLUGIN_GUID);
			val2.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + PLUGIN_GUID + " is loaded!"));
		}
	}
	public static class Assets
	{
		public class RandomAudioClip
		{
			private List<AudioClip> clipList = new List<AudioClip>();

			public AudioClip GetRandomAudio(int seed)
			{
				Random random = new Random();
				int num = random.Next(clipList.Count);
				Console.WriteLine($"Get audio N {clipList.Count} > {num}");
				return clipList[num];
			}

			public void AddAudio(string name)
			{
				AudioClip audioClipFromName = GetAudioClipFromName(name);
				if ((Object)(object)audioClipFromName != (Object)null)
				{
					clipList.Add(audioClipFromName);
				}
				else
				{
					Console.WriteLine("clip " + name + " null");
				}
			}
		}

		public static string mainAssetBundleName = "sylvunnynsfwbundle";

		public static AssetBundle MainAssetBundle = null;

		public static RandomAudioClip SSpawn = new RandomAudioClip();

		public static RandomAudioClip SDance = new RandomAudioClip();

		public static RandomAudioClip SPoint = new RandomAudioClip();

		public static RandomAudioClip SHurt = new RandomAudioClip();

		public static RandomAudioClip SDie = new RandomAudioClip();

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

		public static void PopulateAssets()
		{
			if ((Object)(object)MainAssetBundle == (Object)null)
			{
				Console.WriteLine(GetAssemblyName() + "." + mainAssetBundleName);
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetAssemblyName() + "." + mainAssetBundleName);
				MainAssetBundle = AssetBundle.LoadFromStream(stream);
			}
			SSpawn.AddAudio("SylveonN");
			SDance.AddAudio("Sylveon_HappyN");
			SPoint.AddAudio("Sylveon_AngryN");
			SPoint.AddAudio("Sylveon_Noise2N");
			SHurt.AddAudio("sylv2n");
			SDie.AddAudio("Sylveon_HurtN");
		}

		public static AudioClip GetAudioClipFromName(string name)
		{
			Object obj = MainAssetBundle.LoadAsset(name);
			return (AudioClip)(object)((obj is AudioClip) ? obj : null);
		}
	}
	internal static class LobbyCompatibility
	{
		internal static void Init(int i)
		{
			Version version = Version.Parse(Plugin.PLUGIN_VERSION);
			if (i == 0)
			{
				PluginHelper.RegisterPlugin(Plugin.PLUGIN_GUID, version, (CompatibilityLevel)2, (VersionStrictness)3);
			}
			else
			{
				PluginHelper.RegisterPlugin(Plugin.PLUGIN_GUID, version, (CompatibilityLevel)0, (VersionStrictness)0);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}