using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using EyeRipper;
using HarmonyLib;
using Il2Cpp;
using Il2CppHurricaneVR.Framework.Core;
using Il2CppHurricaneVR.Framework.Core.Grabbers;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "EyeRipper", "1.0.0", "MajedCT", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("EyeRipper")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EyeRipper")]
[assembly: AssemblyTitle("EyeRipper")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EyeRipper
{
	public class Core : MelonMod
	{
		[HarmonyPatch(typeof(HVRHandGrabber), "OnGrabbed")]
		internal class GrabberPatch
		{
			public static void Postfix(HVRHandGrabber __instance)
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)__instance == (Object)null)
				{
					return;
				}
				HVRGrabbable grabbedTarget = ((HVRGrabberBase)__instance).GrabbedTarget;
				if ((Object)(object)grabbedTarget == (Object)null)
				{
					return;
				}
				EyeEjector componentInParent = ((Component)grabbedTarget).GetComponentInParent<EyeEjector>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					if (((Object)grabbedTarget).name == "Eyeball_R")
					{
						componentInParent.EjectRightEye(zeroh);
					}
					else if (((Object)grabbedTarget).name == "Eyeball_L")
					{
						componentInParent.EjectLeftEye(zeroh);
					}
				}
			}
		}

		public static Vector3 zeroh = new Vector3(0f, 0f, 0f);

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Flight;
using Il2Cpp;
using Il2CppHexabodyVR.PlayerController;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.XR;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "Flight", "1.0.0", "Mjdo0", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Flight")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Flight")]
[assembly: AssemblyTitle("Flight")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Flight
{
	public class Core : MelonMod
	{
		public static bool isMainMenu = true;

		public static bool isFlying = false;

		public static Rigidbody[] rigidBodies;

		public static HVRHexaBodyInputs playerInputs;

		public static InputDevice leftHand;

		public static InputDevice rightHand;

		private bool lastJump;

		private float lastClickTime;

		private float doubleClickThreshold = 0.3f;

		public static MelonPreferences_Category category;

		public static MelonPreferences_Entry<float> maxSpeedV;

		public static float flightForce = 1.5f;

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			category = MelonPreferences.CreateCategory("Flight", "Flight Mod Settings");
			maxSpeedV = category.CreateEntry<float>("MaxSpeed", 16f, "Max Speed", "Maximum flight speed (higher is faster, but less controllable)", false, false, (ValueValidator)null, (string)null);
			category.SaveToFile(true);
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			isFlying = false;
			if (sceneName != "MainMenuScene")
			{
				playerInputs = GameObject.Find("HexaBody").GetComponent<HVRHexaBodyInputs>();
				rigidBodies = (Rigidbody[])(object)new Rigidbody[5];
				rigidBodies[0] = GameObject.Find("PlayerUpperChest").GetComponent<Rigidbody>();
				rigidBodies[1] = GameObject.Find("PlayerPelvis").GetComponent<Rigidbody>();
				rigidBodies[2] = GameObject.Find("Knee").GetComponent<Rigidbody>();
				rigidBodies[3] = GameObject.Find("PlayerHexaPelvis").GetComponent<Rigidbody>();
				rigidBodies[4] = GameObject.Find("LocoBall").GetComponent<Rigidbody>();
				isMainMenu = false;
			}
			else
			{
				isMainMenu = true;
			}
		}

		public static void ToggleFlight()
		{
			isFlying = !isFlying;
			if (isFlying)
			{
				Rigidbody[] array = rigidBodies;
				foreach (Rigidbody val in array)
				{
					val.useGravity = false;
				}
			}
			else
			{
				Rigidbody[] array2 = rigidBodies;
				foreach (Rigidbody val2 in array2)
				{
					val2.useGravity = true;
				}
			}
		}

		public override void OnUpdate()
		{
			//IL_012c: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			if (isMainMenu)
			{
				return;
			}
			if (isFlying)
			{
				Vector3 linearVelocity;
				if (((HexaBodyInputsBase)playerInputs).MovementMagnitude > 0.01f)
				{
					Rigidbody[] array = rigidBodies;
					foreach (Rigidbody val in array)
					{
						Transform transform = ((Component)Camera.main).transform;
						Vector3 forward = transform.forward;
						Vector3 right = transform.right;
						forward.y = 0f;
						right.y = 0f;
						((Vector3)(ref forward)).Normalize();
						((Vector3)(ref right)).Normalize();
						Vector3 val2 = right * ((HexaBodyInputsBase)playerInputs).MovementAxis.x + forward * ((HexaBodyInputsBase)playerInputs).MovementAxis.y;
						float value = maxSpeedV.Value;
						linearVelocity = val.linearVelocity;
						float magnitude = ((Vector3)(ref linearVelocity)).magnitude;
						float num = Mathf.Clamp01(1f - magnitude / value);
						val.AddForce(val2 * flightForce * num, (ForceMode)2);
					}
				}
				if (((HexaBodyInputsBase)playerInputs).TurnAxis.y > 0.01f || ((HexaBodyInputsBase)playerInputs).TurnAxis.y < -0.01f)
				{
					Rigidbody[] array2 = rigidBodies;
					foreach (Rigidbody val3 in array2)
					{
						float value2 = maxSpeedV.Value;
						linearVelocity = val3.linearVelocity;
						float magnitude2 = ((Vector3)(ref linearVelocity)).magnitude;
						float num2 = Mathf.Clamp01(1f - magnitude2 / value2);
						val3.AddForce(new Vector3(0f, ((HexaBodyInputsBase)playerInputs).TurnAxis.y, 0f) * flightForce * num2, (ForceMode)2);
					}
				}
			}
			bool jumpPressed = ((HexaBodyInputsBase)playerInputs).JumpPressed;
			if (jumpPressed && !lastJump)
			{
				if (Time.time - lastClickTime < doubleClickThreshold)
				{
					ToggleFlight();
				}
				lastClickTime = Time.time;
			}
			lastJump = jumpPressed;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using HarmonyLib;
using Il2Cpp;
using Il2CppDinoFracture;
using Il2CppHurricaneVR.Framework.Core;
using Il2CppHurricaneVR.Framework.Core.Grabbers;
using Il2CppSystem;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using RipAndTear;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "RipAndTear", "1.2.0", "MajedCT", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RipAndTear")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RipAndTear")]
[assembly: AssemblyTitle("RipAndTear")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RipAndTear
{
	public class Core : MelonMod
	{
		[HarmonyPatch(typeof(HVRGrabbable), "InternalOnGrabbed")]
		public static class PatchGrab
		{
			private static void Postfix(HVRGrabbable __instance)
			{
				if ((((Object)__instance).name == "Neck" && !removeNeckGib.Value) || ((Object)__instance).name == "Head" || ((Object)__instance).name == "Jaw" || ((Object)__instance).name == "UpperChest" || ((Object)__instance).name == "MiddleChest" || ((Object)__instance).name == "Knee_L" || ((Object)__instance).name == "Pelvis" || ((Object)__instance).name == "Shoulder_R" || ((Object)__instance).name == "Elbow_R" || ((Object)__instance).name == "Elbow_L" || ((Object)__instance).name == "Hip_R" || ((Object)__instance).name == "Shoulder_L" || ((Object)__instance).name == "Knee_R" || ((Object)__instance).name == "Hip_L" || ((Object)__instance).name == "Foot_R" || ((Object)__instance).name == "Foot_L")
				{
					SliceOnInputCustom component = ((Component)__instance).GetComponent<SliceOnInputCustom>();
					HVRGrabbable component2 = ((Component)__instance).GetComponent<HVRGrabbable>();
					SliceManager(component, component2, ((Object)__instance).GetInstanceID());
				}
			}
		}

		[HarmonyPatch(typeof(HVRGrabbable), "InternalOnReleased")]
		public static class PatchUnGrab
		{
			private static void Postfix(HVRGrabbable __instance)
			{
				if ((((Object)__instance).name == "Neck" && !removeNeckGib.Value) || ((Object)__instance).name == "Head" || ((Object)__instance).name == "Jaw" || ((Object)__instance).name == "UpperChest" || ((Object)__instance).name == "MiddleChest" || ((Object)__instance).name == "Knee_L" || ((Object)__instance).name == "Pelvis" || ((Object)__instance).name == "Shoulder_R" || ((Object)__instance).name == "Elbow_R" || ((Object)__instance).name == "Elbow_L" || ((Object)__instance).name == "Hip_R" || ((Object)__instance).name == "Shoulder_L" || ((Object)__instance).name == "Knee_R" || ((Object)__instance).name == "Hip_L" || ((Object)__instance).name == "Foot_R" || ((Object)__instance).name == "Foot_L")
				{
					SliceOnInputCustom component = ((Component)__instance).GetComponent<SliceOnInputCustom>();
					HVRGrabbable component2 = ((Component)__instance).GetComponent<HVRGrabbable>();
					SliceManagerNullifier(component, component2, ((Object)__instance).GetInstanceID());
				}
			}
		}

		[CompilerGenerated]
		private sealed class <GrabAfterFracture>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SliceOnInputCustom original;

			public HVRHandGrabber hand;

			public Core <>4__this;

			private Transform <root>5__1;

			private Transform <chunks>5__2;

			private Transform <fracRoot>5__3;

			private HVRGrabbable <best>5__4;

			private float <bestVol>5__5;

			private int <i>5__6;

			private Transform <c>5__7;

			private IEnumerator<HVRGrabbable> <>s__8;

			private HVRGrabbable <g>5__9;

			private Renderer <r>5__10;

			private Vector3 <e>5__11;

			private float <vol>5__12;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<root>5__1 = null;
				<chunks>5__2 = null;
				<fracRoot>5__3 = null;
				<best>5__4 = null;
				<c>5__7 = null;
				<>s__8 = null;
				<g>5__9 = null;
				<r>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<root>5__1 = ((Component)original).transform.parent.parent;
					<chunks>5__2 = <root>5__1.Find("Chunks");
					<fracRoot>5__3 = null;
					<i>5__6 = 0;
					while (<i>5__6 < <chunks>5__2.childCount)
					{
						<c>5__7 = <chunks>5__2.GetChild(<i>5__6);
						if (((Object)<c>5__7).name.Contains(((Object)((Component)original).gameObject).name))
						{
							<fracRoot>5__3 = <c>5__7;
							break;
						}
						<i>5__6++;
					}
					<best>5__4 = null;
					<bestVol>5__5 = 0f;
					<>s__8 = ((Component)<fracRoot>5__3).gameObject.GetComponentsInChildren<HVRGrabbable>(true).GetEnumerator();
					try
					{
						while (<>s__8.MoveNext())
						{
							<g>5__9 = <>s__8.Current;
							<r>5__10 = ((Component)<g>5__9).GetComponentInChildren<Renderer>();
							if (!((Object)(object)<r>5__10 == (Object)null))
							{
								Bounds bounds = <r>5__10.bounds;
								<e>5__11 = ((Bounds)(ref bounds)).extents;
								<vol>5__12 = <e>5__11.x * <e>5__11.y * <e>5__11.z;
								if (<vol>5__12 > <bestVol>5__5)
								{
									<bestVol>5__5 = <vol>5__12;
									<best>5__4 = <g>5__9;
								}
								<r>5__10 = null;
								<g>5__9 = null;
							}
						}
					}
					finally
					{
						if (<>s__8 != null)
						{
							<>s__8.Dispose();
						}
					}
					<>s__8 = null;
					if ((Object)(object)<best>5__4 != (Object)null)
					{
						Debug.Log(Object.op_Implicit("Grabbing chunk: " + ((Object)<best>5__4).name));
						((HVRGrabberBase)hand).ForceRelease();
						((HVRGrabberBase)hand).TryGrab(<best>5__4, false);
					}
					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 static HVRHexaBodyInputs playerInputs;

		public static HVRHandGrabber leftHand;

		public static HVRHandGrabber rightHand;

		public static SliceOnInputCustom slice1;

		public static SliceOnInputCustom slice2;

		public static int id1;

		public static int id2;

		public static HVRGrabbable grab1;

		public static HVRGrabbable grab2;

		public static MelonPreferences_Category category;

		public static MelonPreferences_Entry<bool> removeNeckGib;

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			category = MelonPreferences.CreateCategory("RipAndTear");
			removeNeckGib = category.CreateEntry<bool>("Don't gib neck", false, "Don't gib neck", "Disable neck gibbing to work with Choke Mod", false, false, (ValueValidator)null, (string)null);
			category.SaveToFile(true);
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			if (sceneName != "MainMenuScene")
			{
				playerInputs = GameObject.Find("Hexa4Rig26.10.23").GetComponentInChildren<HVRHexaBodyInputs>();
				leftHand = GameObject.Find("Hexa4Rig26.10.23").GetComponentInChildren<HVRHandGrabber>();
				GameObject val = GameObject.Find("Hexa4Rig26.10.23");
				leftHand = ((Component)val.transform.Find("Physics LeftHand")).GetComponent<HVRHandGrabber>();
				rightHand = ((Component)val.transform.Find("Physics RightHand")).GetComponent<HVRHandGrabber>();
			}
		}

		public static void SliceManager(SliceOnInputCustom slicer, HVRGrabbable grab, int id)
		{
			if ((Object)(object)grab1 == (Object)null && (Object)(object)slice1 == (Object)null && id1 == 0)
			{
				grab1 = grab;
				slice1 = slicer;
				id1 = id;
			}
			else if ((Object)(object)grab1 != (Object)null && (((Object)(object)slice1 != (Object)null) & (id1 != 0)) && (Object)(object)grab2 == (Object)null && (Object)(object)slice2 == (Object)null && id2 == 0)
			{
				grab2 = grab;
				slice2 = slicer;
				id2 = id;
			}
		}

		public static void SliceManagerNullifier(SliceOnInputCustom slicer, HVRGrabbable grab, int id)
		{
			if (id == id1)
			{
				grab1 = null;
				slice1 = null;
				id1 = 0;
			}
			else if (id == id2)
			{
				grab2 = null;
				slice2 = null;
				id2 = 0;
			}
		}

		[IteratorStateMachine(typeof(<GrabAfterFracture>d__17))]
		private IEnumerator GrabAfterFracture(SliceOnInputCustom original, HVRHandGrabber hand)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GrabAfterFracture>d__17(0)
			{
				<>4__this = this,
				original = original,
				hand = hand
			};
		}

		public override void OnUpdate()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerInputs == (Object)null)
			{
				return;
			}
			if (playerInputs.LeftController.TriggerButtonState.Active)
			{
				if ((Object)(object)grab1 != (Object)null && ((Object)grab1.Grabbers[0]).name == "Physics LeftHand")
				{
					string name = ((Object)((Component)slice1).gameObject).name;
					if (name != "Head" && name != "Pelvis")
					{
						TransferJointsOnFractureCustom componentInParent = ((Component)slice1).GetComponentInParent<TransferJointsOnFractureCustom>();
						componentInParent.DistanceTolerance = 0f;
					}
					if (removeNeckGib.Value && name == "Neck")
					{
						return;
					}
					slice1.ForceFracture();
					if (name.Contains("Elbow") || name.Contains("Shoulder") || name.Contains("Knee") || name.Contains("Hip") || name.Contains("Foot") || name.Contains("Jaw"))
					{
						MelonCoroutines.Start(GrabAfterFracture(slice1, leftHand));
					}
					else
					{
						((HVRGrabberBase)leftHand).ForceRelease();
					}
					SliceManagerNullifier(slice1, grab1, id1);
				}
				else if ((Object)(object)grab2 != (Object)null && ((Object)grab2.Grabbers[0]).name == "Physics LeftHand")
				{
					string name2 = ((Object)((Component)slice2).gameObject).name;
					if (name2 != "Head" && name2 != "Pelvis")
					{
						TransferJointsOnFractureCustom componentInParent2 = ((Component)slice2).GetComponentInParent<TransferJointsOnFractureCustom>();
						componentInParent2.DistanceTolerance = 0f;
					}
					if (removeNeckGib.Value && name2 == "Neck")
					{
						return;
					}
					slice2.ForceFracture();
					if (name2.Contains("Elbow") || name2.Contains("Shoulder") || name2.Contains("Knee") || name2.Contains("Hip") || name2.Contains("Foot") || name2.Contains("Jaw"))
					{
						MelonCoroutines.Start(GrabAfterFracture(slice2, leftHand));
					}
					else
					{
						((HVRGrabberBase)leftHand).ForceRelease();
					}
					SliceManagerNullifier(slice2, grab2, id2);
				}
			}
			if (!playerInputs.RightController.TriggerButtonState.Active)
			{
				return;
			}
			if ((Object)(object)grab1 != (Object)null && ((Object)grab1.Grabbers[0]).name == "Physics RightHand")
			{
				string name3 = ((Object)((Component)slice1).gameObject).name;
				if (name3 != "Head" && name3 != "Pelvis")
				{
					TransferJointsOnFractureCustom componentInParent3 = ((Component)slice1).GetComponentInParent<TransferJointsOnFractureCustom>();
					componentInParent3.DistanceTolerance = 0f;
				}
				if (!removeNeckGib.Value || !(name3 == "Neck"))
				{
					slice1.ForceFracture();
					if (name3.Contains("Elbow") || name3.Contains("Shoulder") || name3.Contains("Knee") || name3.Contains("Hip") || name3.Contains("Foot") || name3.Contains("Jaw"))
					{
						MelonCoroutines.Start(GrabAfterFracture(slice1, rightHand));
					}
					else
					{
						((HVRGrabberBase)rightHand).ForceRelease();
					}
					SliceManagerNullifier(slice1, grab1, id1);
				}
			}
			else
			{
				if (!((Object)(object)grab2 != (Object)null) || !(((Object)grab2.Grabbers[0]).name == "Physics RightHand"))
				{
					return;
				}
				string name4 = ((Object)((Component)slice2).gameObject).name;
				if (name4 != "Head" && name4 != "Pelvis")
				{
					TransferJointsOnFractureCustom componentInParent4 = ((Component)slice2).GetComponentInParent<TransferJointsOnFractureCustom>();
					componentInParent4.DistanceTolerance = 0f;
				}
				if (!removeNeckGib.Value || !(name4 == "Neck"))
				{
					slice2.ForceFracture();
					if (name4.Contains("Elbow") || name4.Contains("Shoulder") || name4.Contains("Knee") || name4.Contains("Hip") || name4.Contains("Foot") || name4.Contains("Jaw"))
					{
						MelonCoroutines.Start(GrabAfterFracture(slice2, rightHand));
					}
					else
					{
						((HVRGrabberBase)rightHand).ForceRelease();
					}
					SliceManagerNullifier(slice2, grab2, id2);
				}
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Il2CppHurricaneVR.Framework.Core.Player;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using SuperStrength;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "SuperStrength", "1.0.0", "Mjdo0", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SuperStrength")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SuperStrength")]
[assembly: AssemblyTitle("SuperStrength")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SuperStrength
{
	public class Core : MelonMod
	{
		public static bool notMainMenu;

		public static HVRHexaBodyHands rightHandS;

		public static HVRHexaBodyHands leftHandS;

		public static MelonPreferences_Category category;

		public static MelonPreferences_Entry<float> spring;

		public static MelonPreferences_Entry<float> torqueSpring;

		public static MelonPreferences_Entry<float> maxTorque;

		public static MelonPreferences_Entry<float> maxForce;

		public static MelonPreferences_Entry<float> damper;

		public static MelonPreferences_Entry<float> torqueDamper;

		public static MelonPreferences_Entry<float> climbDamper;

		public static MelonPreferences_Entry<float> climbSpring;

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
			category = MelonPreferences.CreateCategory("SuperStrength", "Super Strength");
			spring = category.CreateEntry<float>("spring", 1000000f, "Spring", "Game Default: 6500, Mod Default: 1000000", false, false, (ValueValidator)null, (string)null);
			torqueSpring = category.CreateEntry<float>("torqueSpring", 1000000f, "Torque Spring", "Game Default: 1100, Mod Default: 1000000", false, false, (ValueValidator)null, (string)null);
			maxTorque = category.CreateEntry<float>("maxTorque", 1000000f, "Max Torque", "Game Default: 130, Mod Default: 1000000", false, false, (ValueValidator)null, (string)null);
			maxForce = category.CreateEntry<float>("maxForce", 1000000f, "Max Force", "Game Default: 1500, Mod Default: 1000000", false, false, (ValueValidator)null, (string)null);
			damper = category.CreateEntry<float>("damper", 0f, "Damper", "Game Default: 330, Mod Default: 0", false, false, (ValueValidator)null, (string)null);
			torqueDamper = category.CreateEntry<float>("torqueDamper", 0f, "Torque Damper", "Game Default: 60, Mod Default: 0", false, false, (ValueValidator)null, (string)null);
			climbDamper = category.CreateEntry<float>("climbDamper", 0f, "Climb Damper", "Game Default: 5000, Mod Default: 0", false, false, (ValueValidator)null, (string)null);
			climbSpring = category.CreateEntry<float>("climbSpring", 1000000f, "Climb Spring", "Game Default: 25000, Mod Default: 1000000f", false, false, (ValueValidator)null, (string)null);
			category.SaveToFile(true);
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			if (sceneName != "MainMenuScene")
			{
				notMainMenu = true;
				leftHandS = GameObject.Find("Physics LeftHand").GetComponent<HVRHexaBodyHands>();
				rightHandS = GameObject.Find("Physics RightHand").GetComponent<HVRHexaBodyHands>();
				leftHandS.StrengthHandler.CurrentStrength.Spring = spring.Value;
				leftHandS.StrengthHandler.CurrentStrength.TorqueSpring = torqueSpring.Value;
				leftHandS.StrengthHandler.CurrentStrength.MaxTorque = maxTorque.Value;
				leftHandS.StrengthHandler.CurrentStrength.MaxForce = maxForce.Value;
				leftHandS.StrengthHandler.CurrentStrength.Damper = damper.Value;
				leftHandS.StrengthHandler.CurrentStrength.TorqueDamper = torqueDamper.Value;
				leftHandS.OneHandedClimbStrength.Damper = climbDamper.Value;
				leftHandS.OneHandedClimbStrength.Spring = climbSpring.Value;
				leftHandS.StrengthHandler.UpdateStrength(leftHandS.StrengthHandler.CurrentStrength);
				rightHandS.StrengthHandler.CurrentStrength.Spring = spring.Value;
				rightHandS.StrengthHandler.CurrentStrength.TorqueSpring = torqueSpring.Value;
				rightHandS.StrengthHandler.CurrentStrength.MaxTorque = maxTorque.Value;
				rightHandS.StrengthHandler.CurrentStrength.MaxForce = maxForce.Value;
				rightHandS.StrengthHandler.CurrentStrength.Damper = damper.Value;
				rightHandS.StrengthHandler.CurrentStrength.TorqueDamper = torqueDamper.Value;
				rightHandS.OneHandedClimbStrength.Damper = climbDamper.Value;
				rightHandS.OneHandedClimbStrength.Spring = climbSpring.Value;
				rightHandS.StrengthHandler.UpdateStrength(rightHandS.StrengthHandler.CurrentStrength);
			}
			else
			{
				notMainMenu = false;
			}
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using HarmonyLib;
using Il2Cpp;
using Il2CppActiveRagdoll;
using Il2CppDinoFracture;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;
using ViltrumiteChop;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "ViltrumiteChop", "1.1.0", "MajedCT", null)]
[assembly: MelonGame("Kubunautilus", "BrutalistickVR")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ViltrumiteChop")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ViltrumiteChop")]
[assembly: AssemblyTitle("ViltrumiteChop")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ViltrumiteChop
{
	public class Core : MelonMod
	{
		[HarmonyPatch(typeof(StickHealth), "HitDetected")]
		internal class HitPatch
		{
			public static void Prefix(StickHealth __instance, ref ColliderBridge colBridge, ref Collision collision, ref string colType, ref string dmgSource, ContactPoint contact)
			{
				if (((Object)colBridge).name != "Neck" || !(dmgSource == "blunt"))
				{
					return;
				}
				GameObject gameObject = ((Component)__instance).gameObject;
				Transform val = gameObject.transform.FindChild("Body");
				SliceOnInputCustom component = ((Component)((Component)val).transform.FindChild("Neck")).GetComponent<SliceOnInputCustom>();
				if (((Object)((Component)component).gameObject).name == "Neck" && (((Object)collision.gameObject).name == "Physics LeftHand" || ((Object)collision.gameObject).name == "Physics RightHand"))
				{
					TransferJointsOnFractureCustom componentInParent = ((Component)component).GetComponentInParent<TransferJointsOnFractureCustom>();
					componentInParent.DistanceTolerance = 0f;
					component.ForceFracture();
					if ((Object)(object)Core.killCount != (Object)null && !__instance.isDead)
					{
						__instance.isDead = true;
						KillCounterScript killCount = Core.killCount;
						int decapitationKillsCounted = killCount.decapitationKillsCounted;
						killCount.decapitationKillsCounted = decapitationKillsCounted + 1;
					}
				}
			}
		}

		public static KillCounterScript killCount;

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			killCount = null;
			if (!(sceneName != "MainMenuScene") || !(sceneName != "MainHub"))
			{
				return;
			}
			Il2CppArrayBase<KillCounterScript> val = Object.FindObjectsOfType<KillCounterScript>(true);
			foreach (KillCounterScript item in val)
			{
				if ((Object)(object)item != (Object)null)
				{
					killCount = item;
					break;
				}
			}
		}
	}
}