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 BoneLib;
using BoneLib.BoneMenu;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Bonelab;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Data;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSLZ.VRMK;
using Il2CppSystem;
using LabFusion.Entities;
using LabFusion.Marrow.Pool;
using LabFusion.Network;
using LabFusion.Network.Serialization;
using LabFusion.RPC;
using LabFusion.SDK.Modules;
using MelonLoader;
using Microsoft.CodeAnalysis;
using PVPMultiversal;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.VFX;
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(PVPMultiversalMod), "PVP Multiversal", "0.5.127", "BONES", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("PVP Multiversal")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.5.127.0")]
[assembly: AssemblyInformationalVersion("0.5.127")]
[assembly: AssemblyProduct("PVP Multiversal")]
[assembly: AssemblyTitle("PVP Multiversal")]
[assembly: AssemblyVersion("0.5.127.0")]
[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 PVPMultiversal
{
	public sealed class PVPMultiversalMod : MelonMod
	{
		private enum KitMode
		{
			None,
			Yuji,
			YujiUltimate,
			Sukuna,
			SukunaUltimate,
			Homelander,
			HomelanderV1,
			Gojo,
			GojoUltimate,
			Toji
		}

		private enum KitSelection
		{
			None,
			Yuji,
			Sukuna,
			Homelander,
			Gojo,
			Toji
		}

		private enum PreferredHand
		{
			Left,
			Right
		}

		private enum DashHandSide
		{
			Right,
			Left
		}

		private enum DashTargetPart
		{
			Head,
			Chest,
			Pelvis
		}

		private enum DomainMaterialRole
		{
			Stone,
			Red,
			DarkRed,
			Roof,
			Mouth,
			Bone
		}

		private enum DomainKind
		{
			Sukuna,
			Gojo
		}

		private sealed class RosterAvatar
		{
			public string DisplayName { get; }

			public Color Color { get; }

			public KitSelection Kit { get; }

			public string[] Barcodes { get; }

			public RosterAvatar(string displayName, Color color, KitSelection kit, params string[] barcodes)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				DisplayName = displayName;
				Color = color;
				Kit = kit;
				Barcodes = barcodes ?? Array.Empty<string>();
			}
		}

		private sealed class AbilitySpec
		{
			public string Name { get; }

			public string Barcode { get; }

			public float Cooldown { get; }

			public float Damage { get; }

			public float Launch { get; }

			public float Radius { get; }

			public float SelfDampRadius { get; }

			public bool VisualOnly { get; }

			public AbilitySpec(string name, string barcode, float cooldown, float damage, float launch, float radius, float selfDampRadius, bool visualOnly = false)
			{
				Name = name;
				Barcode = barcode;
				Cooldown = cooldown;
				Damage = damage;
				Launch = launch;
				Radius = radius;
				SelfDampRadius = selfDampRadius;
				VisualOnly = visualOnly;
			}
		}

		private sealed class RemoteLaserVisual
		{
			public GameObject Object;

			public Vector3 Position;

			public Quaternion Rotation;

			public bool V1;

			public float ExpiresAt;
		}

		private sealed class RemoteBloodManipulationVisual
		{
			public GameObject Object;

			public bool LocalDamaged;

			public float ExpiresAt;
		}

		private sealed class DomainSlashVisual
		{
			public float HideAt;

			public GameObject Object { get; }

			public DomainSlashVisual(GameObject obj)
			{
				Object = obj;
			}
		}

		private sealed class DomainPlayerTarget
		{
			public RigManager Rig { get; }

			public Collider Collider { get; }

			public Vector3 Point { get; }

			public DomainPlayerTarget(RigManager rig, Collider collider, Vector3 point)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				Rig = rig;
				Collider = collider;
				Point = point;
			}
		}

		private sealed class DomainCastRecord
		{
			public byte OwnerId { get; }

			public DomainKind Kind { get; }

			public Vector3 Center { get; }

			public Quaternion Rotation { get; }

			public float CastTime { get; }

			public bool LocalOwner { get; }

			public DomainCastRecord(byte ownerId, DomainKind kind, Vector3 center, Quaternion rotation, float castTime, bool localOwner)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				OwnerId = ownerId;
				Kind = kind;
				Center = center;
				Rotation = rotation;
				CastTime = castTime;
				LocalOwner = localOwner;
			}
		}

		private sealed class DomainClashParticipant
		{
			public byte OwnerId { get; }

			public DomainKind Kind { get; }

			public Vector3 Center { get; }

			public Quaternion Rotation { get; }

			public bool LocalOwner { get; }

			public float Score { get; set; }

			public DomainClashParticipant(DomainCastRecord record)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				OwnerId = record.OwnerId;
				Kind = record.Kind;
				Center = record.Center;
				Rotation = record.Rotation;
				LocalOwner = record.LocalOwner;
			}
		}

		private sealed class FrozenBodyState
		{
			public Rigidbody Body { get; }

			public RigidbodyConstraints Constraints { get; }

			public bool UseGravity { get; }

			public float Drag { get; }

			public float AngularDrag { get; }

			public float RestoreAt { get; set; }

			public FrozenBodyState(Rigidbody body, RigidbodyConstraints constraints, bool useGravity, float drag, float angularDrag)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				Body = body;
				Constraints = constraints;
				UseGravity = useGravity;
				Drag = drag;
				AngularDrag = angularDrag;
			}
		}

		private sealed class AvatarBalanceStats
		{
			public float Agility { get; }

			public float StrengthUpper { get; }

			public float StrengthLower { get; }

			public float Vitality { get; }

			public float Speed { get; }

			public float Intelligence { get; }

			public AvatarBalanceStats(float agility, float strengthUpper, float strengthLower, float vitality, float speed, float intelligence)
			{
				Agility = agility;
				StrengthUpper = strengthUpper;
				StrengthLower = strengthLower;
				Vitality = vitality;
				Speed = speed;
				Intelligence = intelligence;
			}
		}

		private sealed class TimedStatsSnapshot
		{
			public Avatar Avatar { get; }

			public float RestoreAt { get; }

			public float Agility { get; }

			public float StrengthUpper { get; }

			public float StrengthLower { get; }

			public float Vitality { get; }

			public float Speed { get; }

			public float Intelligence { get; }

			public TimedStatsSnapshot(Avatar avatar, float restoreAt)
			{
				Avatar = avatar;
				RestoreAt = restoreAt;
				Agility = avatar._agility;
				StrengthUpper = avatar._strengthUpper;
				StrengthLower = avatar._strengthLower;
				Vitality = avatar._vitality;
				Speed = avatar._speed;
				Intelligence = avatar._intelligence;
			}
		}

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

			private object <>2__current;

			public Collider collider;

			public Vector3 direction;

			public Vector3 originalPoint;

			public PVPMultiversalMod <>4__this;

			private Vector3 <point>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: 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 = (object)new WaitForSeconds(0.34f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)collider == (Object)null)
					{
						return false;
					}
					<point>5__1 = originalPoint;
					try
					{
						<point>5__1 = collider.ClosestPoint(originalPoint);
					}
					catch
					{
					}
					<>4__this.SpawnYujiDivergentFistVisual(<point>5__1, direction, delayed: true);
					<>4__this.PlayYujiImpactSound(<point>5__1, delayed: true, blackFlash: false);
					<>4__this.DamageCollider(collider, direction, <point>5__1, 10f);
					<>4__this.ApplyLaunch(collider, direction, 24f);
					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();
			}
		}

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

			private object <>2__current;

			public GameObject visual;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public float speed;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <travel>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 90f);
					speed = Mathf.Max(1f, speed);
					<startedAt>5__1 = Time.time;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)visual != (Object)null)
				{
					<travel>5__2 = Mathf.Clamp((Time.time - <startedAt>5__1) * speed, 0f, distance);
					visual.transform.position = start + direction * <travel>5__2;
					if (<travel>5__2 >= distance)
					{
						Object.Destroy((Object)(object)visual);
						return false;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				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();
			}
		}

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

			private object <>2__current;

			public int serial;

			public PVPMultiversalMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				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 = (object)new WaitForSeconds(0.15f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (serial != <>4__this._selectionResetSerial)
					{
						return false;
					}
					<>4__this.RespawnLocalPlayer();
					<>4__this.ApplyPvpRosterHealth();
					<>4__this.ApplyCurrentKitBalanceStats();
					<>4__this.ResetLocalPvpHealth();
					<>4__this.SuppressBodyLogDevices();
					<>2__current = (object)new WaitForSeconds(0.35f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (serial != <>4__this._selectionResetSerial)
					{
						return false;
					}
					<>4__this.ApplyPvpRosterHealth();
					<>4__this.ApplyCurrentKitBalanceStats();
					<>4__this.ResetLocalPvpHealth();
					<>4__this.SuppressBodyLogDevices();
					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();
			}
		}

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

			private object <>2__current;

			public GameObject visual;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <endAt>5__1;

			private float <nextNetworkAt>5__2;

			private HashSet<int> <damaged>5__3;

			private bool <hasSmoothedPose>5__4;

			private Vector3 <smoothedPosition>5__5;

			private Quaternion <smoothedRotation>5__6;

			private Vector3 <position>5__7;

			private Quaternion <rotation>5__8;

			private Vector3 <direction>5__9;

			private float <blend>5__10;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: 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_00b0: 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_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<endAt>5__1 = Time.time + 1.25f;
					<nextNetworkAt>5__2 = 0f;
					<damaged>5__3 = new HashSet<int>();
					<hasSmoothedPose>5__4 = false;
					<smoothedPosition>5__5 = Vector3.zero;
					<smoothedRotation>5__6 = Quaternion.identity;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Time.time < <endAt>5__1)
				{
					if (!<>4__this.TryResolveBloodManipulationAimPose(out <position>5__7, out <rotation>5__8))
					{
						if ((Object)(object)visual == (Object)null)
						{
							return false;
						}
						<position>5__7 = visual.transform.position;
						<rotation>5__8 = visual.transform.rotation;
					}
					<direction>5__9 = <rotation>5__8 * Vector3.forward;
					<direction>5__9 = ((((Vector3)(ref <direction>5__9)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref <direction>5__9)).normalized : Vector3.forward);
					if ((Object)(object)visual != (Object)null)
					{
						if (!<hasSmoothedPose>5__4)
						{
							<smoothedPosition>5__5 = <position>5__7;
							<smoothedRotation>5__6 = <rotation>5__8;
							<hasSmoothedPose>5__4 = true;
						}
						else
						{
							<blend>5__10 = 1f - Mathf.Exp(-32f * Time.deltaTime);
							<smoothedPosition>5__5 = Vector3.Lerp(<smoothedPosition>5__5, <position>5__7, <blend>5__10);
							<smoothedRotation>5__6 = Quaternion.Slerp(<smoothedRotation>5__6, <rotation>5__8, <blend>5__10);
						}
						visual.transform.SetPositionAndRotation(<smoothedPosition>5__5, <smoothedRotation>5__6);
					}
					<>4__this.ApplyYujiBloodManipulationDamageSegment(<position>5__7, <position>5__7 + <direction>5__9 * distance, <direction>5__9, <damaged>5__3);
					if (Time.time >= <nextNetworkAt>5__2)
					{
						<nextNetworkAt>5__2 = Time.time + 0.08f;
						<>4__this.BroadcastPvpEvent(PvpNetEventData.Create(16, <position>5__7, <rotation>5__8, flag: true, distance), reliable: false);
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)visual != (Object)null)
				{
					Object.Destroy((Object)(object)visual);
				}
				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();
			}
		}

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private HashSet<int> <damaged>5__3;

			private float <travel>5__4;

			private float <fromTravel>5__5;

			private Vector3 <from>5__6;

			private Vector3 <to>5__7;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 80f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					<damaged>5__3 = new HashSet<int>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__4 = Mathf.Clamp((Time.time - <startedAt>5__1) * Mathf.Max(1f, 38f), 0f, distance);
				if (<travel>5__4 >= 5f)
				{
					<fromTravel>5__5 = Mathf.Max(5f, <lastTravel>5__2);
					<from>5__6 = start + direction * <fromTravel>5__5;
					<to>5__7 = start + direction * <travel>5__4;
					<>4__this.ApplyHollowPurpleDamageSegment(<from>5__6, <to>5__7, direction, <damaged>5__3);
				}
				if (<travel>5__4 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__4;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private float <travel>5__3;

			private float <fromTravel>5__4;

			private Vector3 <from>5__5;

			private Vector3 <to>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: 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_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 80f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__3 = Mathf.Clamp((Time.time - <startedAt>5__1) * Mathf.Max(1f, 38f), 0f, distance);
				if (<travel>5__3 >= 5f)
				{
					<fromTravel>5__4 = Mathf.Max(5f, <lastTravel>5__2);
					<from>5__5 = start + direction * <fromTravel>5__4;
					<to>5__6 = start + direction * <travel>5__3;
					if (<>4__this.ApplyLocalHollowPurpleDamageSegment(<from>5__5, <to>5__6, direction))
					{
						return false;
					}
				}
				if (<travel>5__3 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__3;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private float <travel>5__3;

			private Vector3 <from>5__4;

			private Vector3 <to>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 90f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__3 = Mathf.Clamp((Time.time - <startedAt>5__1) * 30f, 0f, distance);
				<from>5__4 = start + direction * <lastTravel>5__2;
				<to>5__5 = start + direction * <travel>5__3;
				if (<>4__this.ApplyLocalSukunaCleaveWebDamageSegment(<from>5__4, <to>5__5, direction))
				{
					return false;
				}
				if (<travel>5__3 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__3;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private float <travel>5__3;

			private Vector3 <from>5__4;

			private Vector3 <to>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 90f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__3 = Mathf.Clamp((Time.time - <startedAt>5__1) * 26f, 0f, distance);
				<from>5__4 = start + direction * <lastTravel>5__2;
				<to>5__5 = start + direction * <travel>5__3;
				if (<>4__this.ApplyLocalSukunaDismantleNetDamageSegment(<from>5__4, <to>5__5, direction))
				{
					return false;
				}
				if (<travel>5__3 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__3;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private float <travel>5__3;

			private Vector3 <from>5__4;

			private Vector3 <to>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 65f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__3 = Mathf.Clamp((Time.time - <startedAt>5__1) * Mathf.Max(1f, 75f), 0f, distance);
				<from>5__4 = start + direction * <lastTravel>5__2;
				<to>5__5 = start + direction * <travel>5__3;
				if (<>4__this.ApplyLocalYujiBloodManipulationDamageSegment(<from>5__4, <to>5__5, direction))
				{
					return false;
				}
				if (<travel>5__3 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__3;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private HashSet<int> <damaged>5__3;

			private float <travel>5__4;

			private Vector3 <from>5__5;

			private Vector3 <to>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 90f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					<damaged>5__3 = new HashSet<int>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__4 = Mathf.Clamp((Time.time - <startedAt>5__1) * 30f, 0f, distance);
				<from>5__5 = start + direction * <lastTravel>5__2;
				<to>5__6 = start + direction * <travel>5__4;
				<>4__this.ApplySukunaCleaveWebDamageSegment(<from>5__5, <to>5__6, direction, <damaged>5__3);
				if (<travel>5__4 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__4;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private HashSet<int> <damaged>5__3;

			private float <travel>5__4;

			private Vector3 <from>5__5;

			private Vector3 <to>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 90f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					<damaged>5__3 = new HashSet<int>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__4 = Mathf.Clamp((Time.time - <startedAt>5__1) * 26f, 0f, distance);
				<from>5__5 = start + direction * <lastTravel>5__2;
				<to>5__6 = start + direction * <travel>5__4;
				<>4__this.ApplySukunaDismantleNetDamageSegment(<from>5__5, <to>5__6, direction, <damaged>5__3);
				if (<travel>5__4 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__4;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

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

			private object <>2__current;

			public Vector3 start;

			public Vector3 direction;

			public float distance;

			public PVPMultiversalMod <>4__this;

			private float <startedAt>5__1;

			private float <lastTravel>5__2;

			private HashSet<int> <damaged>5__3;

			private float <travel>5__4;

			private Vector3 <from>5__5;

			private Vector3 <to>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.0004f) ? ((Vector3)(ref direction)).normalized : Vector3.forward);
					distance = Mathf.Clamp(distance, 0.5f, 65f);
					<startedAt>5__1 = Time.time;
					<lastTravel>5__2 = 0f;
					<damaged>5__3 = new HashSet<int>();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<travel>5__4 = Mathf.Clamp((Time.time - <startedAt>5__1) * Mathf.Max(1f, 75f), 0f, distance);
				<from>5__5 = start + direction * <lastTravel>5__2;
				<to>5__6 = start + direction * <travel>5__4;
				<>4__this.ApplyYujiBloodManipulationDamageSegment(<from>5__5, <to>5__6, direction, <damaged>5__3);
				if (<travel>5__4 >= distance)
				{
					return false;
				}
				<lastTravel>5__2 = <travel>5__4;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}

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

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

		[CompilerGenerated]
		private sealed class <GetCoreBodyRigidbodies>d__823 : IEnumerable<Rigidbody>, IEnumerable, IEnumerator<Rigidbody>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Rigidbody <>2__current;

			private int <>l__initialThreadId;

			public PVPMultiversalMod <>4__this;

			private PhysTorso <torso>5__1;

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

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

			[DebuggerHidden]
			public <GetCoreBodyRigidbodies>d__823(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)<>4__this._physicsRig == (Object)null)
					{
						return false;
					}
					<torso>5__1 = <>4__this._physicsRig.torso;
					if ((Object)(object)<torso>5__1 != (Object)null)
					{
						if ((Object)(object)<torso>5__1.rbPelvis != (Object)null)
						{
							<>2__current = <torso>5__1.rbPelvis;
							<>1__state = 1;
							return true;
						}
						goto IL_00d6;
					}
					goto IL_01b7;
				case 1:
					<>1__state = -1;
					goto IL_00d6;
				case 2:
					<>1__state = -1;
					goto IL_010e;
				case 3:
					<>1__state = -1;
					goto IL_0146;
				case 4:
					<>1__state = -1;
					goto IL_017e;
				case 5:
					<>1__state = -1;
					goto IL_01b7;
				case 6:
					<>1__state = -1;
					goto IL_01f9;
				case 7:
					{
						<>1__state = -1;
						break;
					}
					IL_01b7:
					if ((Object)(object)<>4__this._physicsRig.rbKnee != (Object)null)
					{
						<>2__current = <>4__this._physicsRig.rbKnee;
						<>1__state = 6;
						return true;
					}
					goto IL_01f9;
					IL_0146:
					if ((Object)(object)<torso>5__1.rbNeck != (Object)null)
					{
						<>2__current = <torso>5__1.rbNeck;
						<>1__state = 4;
						return true;
					}
					goto IL_017e;
					IL_017e:
					if ((Object)(object)<torso>5__1.rbHead != (Object)null)
					{
						<>2__current = <torso>5__1.rbHead;
						<>1__state = 5;
						return true;
					}
					goto IL_01b7;
					IL_00d6:
					if ((Object)(object)<torso>5__1.rbSpine != (Object)null)
					{
						<>2__current = <torso>5__1.rbSpine;
						<>1__state = 2;
						return true;
					}
					goto IL_010e;
					IL_01f9:
					if ((Object)(object)<>4__this._physicsRig.rbFeet != (Object)null)
					{
						<>2__current = <>4__this._physicsRig.rbFeet;
						<>1__state = 7;
						return true;
					}
					break;
					IL_010e:
					if ((Object)(object)<torso>5__1.rbChest != (Object)null)
					{
						<>2__current = <torso>5__1.rbChest;
						<>1__state = 3;
						return true;
					}
					goto IL_0146;
				}
				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();
			}

			[DebuggerHidden]
			IEnumerator<Rigidbody> IEnumerable<Rigidbody>.GetEnumerator()
			{
				<GetCoreBodyRigidbodies>d__823 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetCoreBodyRigidbodies>d__823(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Rigidbody>)this).GetEnumerator();
			}
		}

		private const float DoubleTapThreshold = 0.32f;

		private const float SpawnForwardOffset = 0.28f;

		private const float SukunaUltimateDuration = 90f;

		private const float YujiUltimateCooldown = 600f;

		private const float YujiUltimateDuration = 90f;

		private const float YujiAwakenedStatsMultiplier = 1.25f;

		private const float SukunaUltimateCooldown = 600f;

		private const float SukunaUltimateStatsMultiplier = 1.25f;

		private const float SukunaTestUltimateReadyDelay = 5f;

		private const float YujiTestUltimateReadyDelay = 5f;

		private const float GojoTestUltimateReadyDelay = 5f;

		private const float IAmYouDuration = 30f;

		private const float IAmYouStatsMultiplier = 1.25f;

		private const float HomelanderUltimateCooldown = 600f;

		private const float HomelanderV1Duration = 90f;

		private const float GojoUltimateCooldown = 600f;

		private const float GojoUltimateDuration = 90f;

		private const float GojoUltimateStatsMultiplier = 1.25f;

		private const float TojiHeavenlyRestrictionDuration = 20f;

		private const float TojiHeavenlyRestrictionMultiplier = 1.25f;

		private const float HomelanderLaserDuration = 5f;

		private const float HomelanderFlightDuration = 30f;

		private const float HomelanderFlightCooldown = 40f;

		private const float HomelanderFlightMoveSpeed = 85f;

		private const float HomelanderFlightVerticalSpeed = 65f;

		private const float HomelanderFlightDamping = 14f;

		private const float HomelanderFlightHandFollow = 85f;

		private const float HomelanderV1StatsMultiplier = 1.5f;

		private const float PvpNonUltimateAttackDamage = 22f;

		private const float PvpUltimateAttackDamage = 32f;

		private const float PvpHollowPurpleDamage = 32f;

		private const float PvpSingleSlashDamage = 22f;

		private const float PvpDismantleDamage = 22f;

		private const float PvpHitMoveLockSeconds = 0.85f;

		private const float PvpLapseBlueMoveLockRefresh = 0.35f;

		private const float PvpBaseHealthRegenFactor = 0.5f;

		private const float YujiDivergentFistCooldown = 15f;

		private const float YujiDivergentFistFirstDamage = 12f;

		private const float YujiDivergentFistSecondDamage = 10f;

		private const float YujiDivergentFistDelay = 0.34f;

		private const float YujiDivergentFistFirstLaunch = 8f;

		private const float YujiDivergentFistSecondLaunch = 24f;

		private const float YujiRareBlackFlashDamage = 22f;

		private const float YujiRareBlackFlashLaunch = 34f;

		private const float YujiRareBlackFlashRadius = 1.65f;

		private const float YujiBloodManipulationCooldown = 18f;

		private const float YujiBloodManipulationDamage = 22f;

		private const float YujiBloodManipulationLaunch = 2f;

		private const float YujiBloodManipulationHitRadius = 0.82f;

		private const float YujiBloodManipulationAimRadius = 1.1f;

		private const float YujiBloodManipulationAimDistance = 65f;

		private const float YujiBloodManipulationVisualScale = 0.75f;

		private const float YujiBloodManipulationLifetime = 1.25f;

		private const float YujiBloodManipulationNetworkInterval = 0.08f;

		private const float YujiBloodManipulationTravelSpeed = 75f;

		private const float YujiBloodManipulationFallbackDistance = 18f;

		private const float YujiBloodManipulationVisualLineLength = 34f;

		private const float YujiSoulDismantleCooldown = 18f;

		private const float YujiSoulDismantleDamage = 32f;

		private const float YujiSoulDismantleLaunch = 10f;

		private const float YujiSoulDismantleRadius = 3.4f;

		private const int PvpMaxCriticalStacks = 5;

		private const float HomelanderLaserDamage = 4f;

		private const float HomelanderLaserLaunch = 4f;

		private const float HomelanderV1LaserDamage = 6f;

		private const float HomelanderV1LaserLaunch = 8f;

		private const float FallbackYujiStrength = 4f;

		private const float FallbackYujiAgility = 4f;

		private const float FallbackYujiSpeed = 4f;

		private const float FallbackYujiIntelligence = 4f;

		private const float SukunaBaseStrengthMultiplier = 1f;

		private const float PvpRosterVitality = 225f;

		private const float FallbackYujiVitality = 225f;

		private const float DashDefaultBaseSpeed = 20f;

		private const float DashDefaultIncrement = 5f;

		private const float DashCooldownSeconds = 1.5f;

		private const float DashResetAfterSeconds = 3f;

		private const float DashPhaseSafetySeconds = 5f;

		private const float SukunaDomainDuration = 40f;

		private const float SukunaDomainCooldown = 60f;

		private const float SukunaDomainRadius = 32f;

		private const float SukunaDomainFloorRadius = 16f;

		private const float SukunaDomainBaselineLength = 34f;

		private const float SukunaDomainHeight = 6.5f;

		private const float SukunaDomainBeatInterval = 0.42f;

		private const float SukunaDomainBeatLeadIn = 11f;

		private const float SukunaDomainShrineRiseDuration = 9f;

		private const float SukunaDomainShrineRiseDepth = 1.25f;

		private const float SukunaDomainNetworkSyncInterval = 2f;

		private const int SukunaDomainSlashesPerBeat = 7;

		private const int SukunaDomainSlashPoolSize = 40;

		private const float SukunaDomainSlashScale = 4.8f;

		private const float SukunaDomainSlashLifetime = 1.1f;

		private const float SukunaDomainSlashDamage = 42f;

		private const float SukunaShrineViewDistance = 10f;

		private const float DomainClashWindow = 0.7f;

		private const float DomainClashDuration = 15f;

		private const float DomainClashTriggerRadius = 28f;

		private const float DomainClashVisualRadius = 14f;

		private const int DomainClashMaxPlayers = 5;

		private const float SukunaBlackFlashDamage = 22f;

		private const float SukunaSingleSlashDamage = 22f;

		private const float SukunaDismantleDamage = 22f;

		private const float SukunaWorldDismantleDamage = 32f;

		private const float SukunaWorldDismantleLaunch = 22f;

		private const float SukunaWorldDismantleRadius = 4.8f;

		private const float SukunaSingleSlashHitRadius = 2.8f;

		private const float SukunaDismantleHitRadius = 3.8f;

		private const float SukunaSlashDamageDistance = 90f;

		private const float GojoBlackFlashDamage = 22f;

		private const float ReversalRedCooldown = 20f;

		private const float ReversalRedDamage = 22f;

		private const float ReversalRedLaunch = 30f;

		private const float ReversalRedRadius = 4.6f;

		private const float ReversalRedSelfDampRadius = 2.2f;

		private const float ReversalRedVisualScale = 0.05f;

		private const float ReversalRedVisualLifetime = 2.85f;

		private const float ReversalRedFingerForwardOffset = 0f;

		private const float ReversalRedPalmForwardOffset = 0.09f;

		private const float ReversalRedFingerUpOffset = 0.008f;

		private const float ReversalRedMaxPointerDistance = 0.32f;

		private const float ReversalRedAimRadius = 0.45f;

		private const float ReversalRedAimDistance = 60f;

		private const float ReversalRedExplosionDelay = 0.95f;

		private const float ReversalRedExplosionDuration = 0.48f;

		private const float ReversalRedExplosionLocalScale = 0.72f;

		private const float ReversalRedExplosionDamageRadius = 4f;

		private const float ReversalRedFallbackDamageDistance = 9.5f;

		private const float ReversalRedMaxCooldown = 28f;

		private const float ReversalRedMaxDamageMultiplier = 1.4545455f;

		private const float ReversalRedMaxRadiusMultiplier = 1.6f;

		private const float ReversalRedMaxLaunchMultiplier = 1.3f;

		private const float LapseBlueCooldown = 18f;

		private const float LapseBlueDuration = 2.3f;

		private const float LapseBlueRadius = 7.2f;

		private const float LapseBlueDamage = 22f;

		private const float LapseBluePullForce = 18f;

		private const float LapseBlueAimDistance = 45f;

		private const float LapseBlueMaxCooldown = 26f;

		private const float LapseBlueMaxDamageMultiplier = 1.4545455f;

		private const float LapseBlueMaxRadiusMultiplier = 1.25f;

		private const float LapseBlueMaxPullMultiplier = 1.15f;

		private const float HollowPurpleCooldown = 45f;

		private const float HollowPurpleDamage = 32f;

		private const float HollowPurpleRadius = 2.85f;

		private const float HollowPurpleLaunch = 82f;

		private const float HollowPurpleFallbackDamageDistance = 14f;

		private const float HollowPurpleMaxDamageDistance = 80f;

		private const float HollowPurpleDamageArmingDistance = 5f;

		private const float HollowPurpleDamageTravelSpeed = 38f;

		private const float HollowPurpleMinDamageDelay = 0.28f;

		private const float HollowPurpleMaxDamageDelay = 2.5f;

		private const float HollowPurpleVisualLifetime = 5f;

		private const float SukunaFugaCooldown = 35f;

		private const float SukunaFugaDamage = 32f;

		private const float SukunaFugaLaunch = 88f;

		private const float SukunaFugaRadius = 9.5f;

		private const float SukunaFugaFallbackDamageDistance = 16f;

		private const float SukunaFugaVisualLifetime = 4.5f;

		private const float GojoDomainCooldown = 60f;

		private const float GojoDomainDuration = 40f;

		private const float GojoDomainRadius = 28f;

		private const float GojoDomainBarrierHeight = 18f;

		private const float GojoDomainBarrierThickness = 2f;

		private const float GojoDomainBarrierCorrectionPadding = 1.65f;

		private const float GojoDomainFreezeHoldSeconds = 0.45f;

		private const int GojoDomainBarrierSegments = 48;

		private const string YujiAvatarBarcode = "Joshfam21.YujiItadori.Avatar.YujiItadori";

		private static readonly string[] SukunaAvatarBarcodes = new string[2] { "mooks.SukanaHeianEra.Avatar.Sukanaheianera", "mooks.Sukuna.Avatar.Sukuna" };

		private const string HomelanderAvatarBarcode = "Draxolan.TheBoysPack.Avatar.Homelander";

		private static readonly string[] GojoAvatarBarcodes = new string[3] { "Joshfam21.GOJOadultsixeyes.Avatar.GOJOadultsixeyes", "Joshfam21.GOJOadult.Avatar.GOJOadult", "MossMeowscarada.SatoruGojoFortnite.Avatar.SatoruGojoFortnite" };

		private static readonly string[] GojoUltimateAvatarBarcodes = new string[4] { "Joshfam21.GojoShinjukuShowdownArc.Avatar.SatoruGojoShinjukuShowdownArc", "Joshfam21.GOJOadultsixeyes.Avatar.GOJOadultsixeyes", "Joshfam21.GOJOadult.Avatar.GOJOadult", "MossMeowscarada.SatoruGojoFortnite.Avatar.SatoruGojoFortnite" };

		private static readonly string[] TojiAvatarBarcodes = new string[4] { "Joshfam21.TojiFushiguro.Avatar.TojiFushiguro", "Joshfam21.TojiFushiguro.Avatar.TojiFushiguroWorm", "Joshfam21.TojiFushiguroshibuya.Avatar.TojiFushiguroshibuya", "Joshfam21.TojiFushiguroshibuya.Avatar.TojiFushiguroshibuyaworm" };

		private const string BlackFlashBarcode = "Curiosity.BlackFlash.Spawnable.BlackFlash";

		private const string BoomBarcode = "Curiosity.BlackFlash.Spawnable.Boom";

		private const string YujiDivergentFistImpactBarcode = "Curiosity.BlackFlash.Spawnable.l1boom";

		private const string YujiDivergentFistDelayedBarcode = "Curiosity.BlackFlash.Spawnable.Boom2";

		private const string HollowPurpleBarcode = "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.HOLLOWPURPLE";

		private const string SingleSlashBarcode = "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.Singleslash";

		private const string DismantleBarcode = "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.DISMANTLE1";

		private const string TojiPlayfulCloudBarcode = "Fishstick5334.JJKWeaponPack.Spawnable.SharpenedPlayfulCloud";

		private const string LaserEyesBarcode = "BamBaeYoh.LaserEyes.Spawnable.LaserEyes";

		private const string SukunaDomainAudioPath = "C:\\Users\\jackc\\AppData\\Roaming\\Leppsoft\\Sukuna new real domain.mp3";

		private const string SukunaDomainWavPath = "C:\\Program Files (x86)\\Steam\\steamapps\\common\\BONELAB\\UserData\\PVPMultiversal\\SukunaNewRealDomain.wav";

		private const string EmbeddedDomainAudioResource = "SukunaNewRealDomain.wav";

		private const string SukunaUltimateEmbeddedAudioResource = "SukunaUltimate.wav";

		private const string SukunaBigSlashEmbeddedAudioResource = "BigSlash.wav";

		private const string GojoReversalRedEmbeddedAudioResource = "GojoReversalRed.wav";

		private const string GojoReversalRedUltimateEmbeddedAudioResource = "GojoReversalRedUltimate.wav";

		private const string GojoLapseBlueEmbeddedAudioResource = "GojoLapseBlue.wav";

		private const string GojoLapseBlueUltimateEmbeddedAudioResource = "GojoLapseBlueUltimate.wav";

		private const string GojoUltimateEmbeddedAudioResource = "GojoUltimate.wav";

		private const string GojoDomainEmbeddedAudioResource = "GojoDomainExpansion.wav";

		private const string LimitlessCtBundleResourceSuffix = "EmbeddedAssets.LimitlessCT.limitlessct_assets_all.bundle";

		private const string CursedEnergySystemBundleResourceSuffix = "EmbeddedAssets.CursedEnergySystem.CESystem.cesystem_assets_all.bundle";

		private const string BloodManipulationBundleResourceSuffix = "EmbeddedAssets.BloodManipulationCT.bloodmanipulationct_assets_all.bundle";

		private const string BloodManipulationShadersBundleResourceSuffix = "EmbeddedAssets.BloodManipulationCT.BloodManipulationCT_unitybuiltinshaders.bundle";

		private const string SukunaTechniqueBundleResourceSuffix = "EmbeddedAssets.SukunaTechnique.shrinect_assets_all.bundle";

		private const string SukunaTechniqueShadersBundleResourceSuffix = "EmbeddedAssets.SukunaTechnique.ShrineCT_unitybuiltinshaders.bundle";

		private const string ShrineTechBundleResourceSuffix = "EmbeddedAssets.ShrineTech.shrinetechnique_assets_all.bundle";

		private const string ShrineTechShadersBundleResourceSuffix = "EmbeddedAssets.ShrineTech.ShrineTech_unitybuiltinshaders.bundle";

		private const string HomoShrineBundleResourceSuffix = "EmbeddedAssets.HomoShrine.shrine_assets_all.bundle";

		private const string HomoShrineShadersBundleResourceSuffix = "EmbeddedAssets.HomoShrine.HomoShrine_unitybuiltinshaders.bundle";

		private const string HomoShrineDismantleVfxSuffix = "/Dismantle.vfx";

		private const string HomoShrineStrongDismantleVfxSuffix = "/StrongDismantle.vfx";

		private const string HomoShrineCleaveWebVfxSuffix = "/CleaveWeb.vfx";

		private const string HomoShrineDismantleNetVfxSuffix = "/DismantleNet.vfx";

		private const string LimitlessCtRedSmolPrefabPath = "Assets/LimitlessCT/prefabs/RedSmol.prefab";

		private const string LimitlessCtRedOverchargePrefabPath = "Assets/LimitlessCT/prefabs/RedOvercharge.prefab";

		private const string LimitlessCtRedMaxExplosionPrefabPath = "Assets/LimitlessCT/prefabs/RedMaxExplosion.prefab";

		private const string LimitlessCtBluePrefabPath = "Assets/LimitlessCT/prefabs/BlueMaxRanged.prefab";

		private const string LimitlessCtBlueOverchargePrefabPath = "Assets/LimitlessCT/prefabs/BlueOvercharge.prefab";

		private const string LimitlessCtInfiniteVoidPrefabPath = "Assets/LimitlessCT/prefabs/InfiniteVoid.prefab";

		private const string CursedEnergyImpactPrefabPath = "Assets/CESystem/prefabs/CursedEnergyImpact.prefab";

		private const string BloodManipulationPiercingBloodPrefabPath = "Assets/Blood Manipulation/Blood Manip Prefabs/Piercing Blood.prefab";

		private const string SukunaTechniqueShrinePrefabPath = "Assets/ShrineCT/prefabs/MalevolentShrine2.prefab";

		private const string SukunaTechniqueFugaPrefabPath = "Assets/ShrineCT/prefabs/Fuga.prefab";

		private const string ShrineTechCleaveWebPrefabPath = "Assets/ShrineTechnique/Avatar/BigSlash.prefab";

		private const string ShrineTechDismantleNetPrefabPath = "Assets/ShrineTechnique/WaffleDismantle.prefab";

		private const float LimitlessCtRedSmolVisualScale = 0.05f;

		private const float LimitlessCtRedOverchargeVisualScale = 0.13f;

		private const float LimitlessCtRedNormalOverchargeVisualScale = 0.065f;

		private const float LimitlessCtRedMaxExplosionVisualScale = 0.34f;

		private const float LimitlessCtRedMaxUltimateExplosionVisualScale = 1.15f;

		private const float LimitlessCtRedNormalExplosionVisualScale = 0.575f;

		private const float LimitlessCtBlueVisualScale = 0.78f;

		private const float LimitlessCtBlueOverchargeVisualScale = 3.35f;

		private const float LimitlessCtInfiniteVoidVisualScale = 1f;

		private const float CursedEnergyDivergentFirstVisualScale = 0.65f;

		private const float CursedEnergyDivergentDelayedVisualScale = 1.05f;

		private const float SukunaTechniqueShrineVisualScale = 1.35f;

		private const float SukunaTechniqueFugaVisualScale = 1.6f;

		private const float HomoShrineSoulDismantleVisualScale = 1.15f;

		private const float HomoShrineWorldDismantleVisualScale = 1.45f;

		private const float HomoShrineCleaveWebVisualScale = 5.25f;

		private const float HomoShrineDismantleNetVisualScale = 6.25f;

		private const float SukunaUltimateOriginalDismantleScale = 6.5f;

		private const float ShrineTechCleaveWebTargetSize = 5.5f;

		private const float ShrineTechDismantleNetTargetSize = 8.25f;

		private const float ShrineTechBigSlashAcuteRollDegrees = -38f;

		private const float SukunaCleaveWebProjectileDistance = 30f;

		private const float SukunaCleaveWebProjectileSpeed = 30f;

		private const float SukunaDismantleNetProjectileDistance = 34f;

		private const float SukunaDismantleNetProjectileSpeed = 26f;

		private const float TojiPhysicalStrikeCooldown = 12f;

		private const float TojiPhysicalStrikeDamage = 22f;

		private const float TojiPhysicalStrikeLaunch = 22f;

		private const float TojiPhysicalStrikeRadius = 1.45f;

		private const float TojiDashSlashCooldown = 12f;

		private const float TojiDashSlashDamage = 22f;

		private const float TojiDashSlashLaunch = 34f;

		private const float TojiDashSlashRadius = 2.4f;

		private const float TojiDashSlashSpeed = 30f;

		private const float TojiPlayfulCloudCooldown = 25f;

		private const float TojiPlayfulCloudDamage = 22f;

		private const float TojiPlayfulCloudLaunch = 22f;

		private const float TojiPlayfulCloudLifetime = 90f;

		private static readonly RosterAvatar[] Roster = new RosterAvatar[4]
		{
			new RosterAvatar("Yuji Itadori", Color.red, KitSelection.Yuji, "Joshfam21.YujiItadori.Avatar.YujiItadori"),
			new RosterAvatar("Sukuna", new Color(0.62f, 0.05f, 0.05f), KitSelection.Sukuna, SukunaAvatarBarcodes),
			new RosterAvatar("Gojo", new Color(0.35f, 0.75f, 1f), KitSelection.Gojo, GojoAvatarBarcodes),
			new RosterAvatar("Toji Fushiguro", new Color(0.1f, 0.9f, 0.55f), KitSelection.Toji, TojiAvatarBarcodes)
		};

		private static readonly string[] LaserStartMessages = new string[14]
		{
			"Fire", "StartFire", "StartFiring", "StartLaser", "StartLasers", "ActivateLaser", "ActivateLasers", "EnableLaser", "EnableLasers", "OnFire",
			"OnFireDown", "OnTriggerDown", "OnThumbstickDown", "LaserOn"
		};

		private static readonly string[] LaserStopMessages = new string[14]
		{
			"StopFire", "StopFiring", "StopLaser", "StopLasers", "DeactivateLaser", "DeactivateLasers", "DisableLaser", "DisableLasers", "OnFireUp", "OnTriggerUp",
			"OnThumbstickUp", "OnReleased", "Released", "LaserOff"
		};

		private static readonly string[] LaserEffectNameMarkers = new string[8] { "beam", "laser", "fire", "glow", "point", "blast", "vfx", "muzzle" };

		private static readonly string[] LaserHiddenBodyMarkers = new string[9] { "chip", "board", "case", "body", "button", "screen", "panel", "module", "controller" };

		private static readonly int[] DashPhaseKeepLayers = new int[6] { 8, 21, 23, 24, 26, 27 };

		private static readonly int[] DashPhaseFallbackLayers = new int[3] { 8, 23, 24 };

		private static readonly Color ReversalRedColor = new Color(1f, 0.04f, 0.015f, 1f);

		private static readonly string[] ReversalRedHideMarkers = new string[13]
		{
			"blue", "purple", "violet", "hollow", "merge", "combine", "collision", "left", "right", "two",
			"orb1", "orb2", "spawnpoint"
		};

		private static readonly string[] ReversalRedKeepMarkers = new string[10] { "red", "center", "main", "core", "blast", "sphere", "orb", "beam", "vfx", "particle" };

		private static readonly string[] ReversalRedPointerMarkers = new string[12]
		{
			"index", "pointer", "indx", "ind_", "_ind", "finger1", "finger_1", "finger01", "digit1", "digit_1",
			"digit01", "forefinger"
		};

		private static readonly string[] ReversalRedPointerTipMarkers = new string[7] { "tip", "distal", "end", "03", "3", "02", "2" };

		private static readonly string[] SukunaTechniqueShrineSlashMarkers = new string[19]
		{
			"slash", "slashes", "dismantle", "cleave", "slice", "slicer", "cutline", "cut line", "domaincut", "domain cut",
			"blade", "trail", "hitbox", "hurtbox", "damage", "attack", "projectile", "line slash", "slash line"
		};

		private static readonly string[] SukunaTechniqueShrineScriptMarkers = new string[7] { "ShrineCT", "MalevolentShrineItem", "Slash", "Dismantle", "Cleave", "Fuga", "Spell" };

		private static readonly string[] VisualOnlyDamageScriptMarkers = new string[16]
		{
			"damage", "damager", "hitbox", "hurtbox", "hurt", "kill", "health", "attack", "collision", "collider",
			"impact", "explosion", "force", "push", "launch", "knockback"
		};

		private readonly AbilitySpec _yujiBlackFlash = new AbilitySpec("Black Flash", "Curiosity.BlackFlash.Spawnable.BlackFlash", 15f, 22f, 34f, 1.65f, 1f);

		private readonly AbilitySpec _yujiBloodManipulation = new AbilitySpec("Blood Manipulation", string.Empty, 18f, 22f, 2f, 0.82f, 0f);

		private readonly AbilitySpec _yujiSoulDismantle = new AbilitySpec("Soul Dismantle", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.DISMANTLE1", 18f, 32f, 10f, 3.4f, 0.55f, visualOnly: true);

		private readonly AbilitySpec _sukunaBlackFlash = new AbilitySpec("Sukuna Black Flash", "Curiosity.BlackFlash.Spawnable.BlackFlash", 15f, 22f, 24f, 1.55f, 1f);

		private readonly AbilitySpec _singleSlash = new AbilitySpec("Cleave", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.Singleslash", 10f, 22f, 12f, 2.8f, 0.55f);

		private readonly AbilitySpec _dismantle = new AbilitySpec("Dismantle", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.DISMANTLE1", 15f, 22f, 16f, 3.8f, 0.55f, visualOnly: true);

		private readonly AbilitySpec _sukunaWorldDismantle = new AbilitySpec("World Dismantle", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.DISMANTLE1", 22f, 32f, 22f, 4.8f, 0.55f, visualOnly: true);

		private readonly AbilitySpec _sukunaCleaveWeb = new AbilitySpec("Cleave Web", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.Singleslash", 10f, 32f, 12f, 2.8f, 0.55f);

		private readonly AbilitySpec _sukunaDismantleNet = new AbilitySpec("Dismantle Net", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.DISMANTLE1", 22f, 32f, 22f, 4.8f, 0.55f, visualOnly: true);

		private readonly AbilitySpec _homelanderBoom = new AbilitySpec("Boom", "Curiosity.BlackFlash.Spawnable.Boom", 15f, 22f, 48f, 4.2f, 1f);

		private readonly AbilitySpec _gojoBlackFlash = new AbilitySpec("Gojo Black Flash", "Curiosity.BlackFlash.Spawnable.BlackFlash", 15f, 22f, 20f, 1.45f, 1f);

		private readonly AbilitySpec _gojoReversalRed = new AbilitySpec("Reversal Red", "MRSIMSICIOUS.THRAGGPUNCH.Spawnable.HOLLOWPURPLE", 20f, 22f, 30f, 4.6f, 2.2f);

		private readonly AbilitySpec _gojoLapseBlue = new AbilitySpec("Lapse Blue", string.Empty, 18f, 22f, 18f, 7.2f, 1f);

		private readonly HashSet<string> _missingBarcodeWarnings = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private Page _mainPage;

		private Page _kitPage;

		private Page _dashPage;

		private Page _dashPlayersPage;

		private bool _menuRebuildPending;

		private string _lastStatus = "Ready";

		private KitMode _kitMode = KitMode.None;

		private RigManager _rigManager;

		private PhysicsRig _physicsRig;

		private bool _leftSecondaryCurrent;

		private bool _rightSecondaryCurrent;

		private bool _leftSecondaryWasDown;

		private bool _rightSecondaryWasDown;

		private bool _leftStickCurrent;

		private bool _rightStickCurrent;

		private bool _leftStickWasDown;

		private bool _rightStickWasDown;

		private bool _leftStickHeld;

		private bool _rightStickHeld;

		private bool _doubleTapYFiredThisFrame;

		private bool _doubleTapBFiredThisFrame;

		private bool _rightStickPressedThisFrame;

		private bool _faceComboCurrent;

		private bool _faceComboWasDown;

		private bool _faceComboFiredThisFrame;

		private float _lastLeftSecondaryTap = -999f;

		private float _lastRightSecondaryTap = -999f;

		private float _nextYujiBlackFlash;

		private float _nextYujiDivergentFist;

		private float _nextYujiBloodManipulation;

		private float _nextYujiSoulDismantle;

		private float _nextIAmYou;

		private float _nextSukunaBlackFlash;

		private float _nextSingleSlash;

		private float _nextDismantle;

		private float _nextFuga;

		private float _nextHomelanderBoom;

		private float _nextHomelanderLaser;

		private float _nextHomelanderFlight;

		private float _nextHomelanderV1Laser;

		private float _nextHomelanderV1Flight;

		private float _nextGojoBlackFlash;

		private float _nextGojoReversalRed;

		private float _nextGojoLapseBlue;

		private float _nextGojoReversalRedMax;

		private float _nextGojoLapseBlueMax;

		private float _nextGojoHollowPurple;

		private float _nextGojoDomain;

		private float _nextTojiPhysicalStrike;

		private float _nextTojiDashSlash;

		private float _nextTojiPlayfulCloud;

		private float _nextTojiHeavenlyRestriction;

		private float _ultimateReadyAt = -1f;

		private float _ultimateEndsAt = -1f;

		private bool _gojoBlackFlashPunchEnabled = true;

		private bool _pendingHomelanderV1Stats;

		private bool _pendingHomelanderBalanceStats;

		private bool _pendingSukunaBalanceStats;

		private bool _pendingRosterBalanceStats;

		private AvatarBalanceStats _yujiBalanceStats;

		private float _nextCooldownStatusAt;

		private TimedStatsSnapshot _statsSnapshot;

		private GameObject _laserEyesObject;

		private bool _laserEyesLoading;

		private bool _laserEyesActive;

		private bool _laserComponentLogDone;

		private float _laserEyesUntil = -1f;

		private float _nextLaserDamageAt;

		private float _nextLaserModulePulseAt;

		private float _nextNetworkLaserSyncAt;

		private float _nextNetworkWarningAt;

		private float _activeLaserDamage;

		private float _activeLaserLaunch;

		private readonly Dictionary<byte, RemoteLaserVisual> _remoteLasers = new Dictionary<byte, RemoteLaserVisual>();

		private readonly Dictionary<byte, RemoteBloodManipulationVisual> _remoteBloodManipulation = new Dictionary<byte, RemoteBloodManipulationVisual>();

		private readonly HashSet<byte> _remoteLaserLoading = new HashSet<byte>();

		private AudioClip _sukunaUltimateClip;

		private AudioClip _sukunaBigSlashClip;

		private bool _sukunaBigSlashClipLoadAttempted;

		private float _nextSukunaUltimateAudioWarningAt;

		private GameObject _domainRoot;

		private Material _domainFloorMaterial;

		private Material _domainSlashMaterial;

		private Material _sukunaSlashCoreMaterial;

		private Material _sukunaSlashEdgeMaterial;

		private readonly Dictionary<string, Material> _bonelabShrineMaterials = new Dictionary<string, Material>();

		private bool _domainLocalOwner;

		private Transform _domainShrineRoot;

		private Vector3 _domainShrineRootFinalLocalPosition;

		private GameObject _gojoDomainRoot;

		private float _domainStartedAt = -1f;

		private float _domainUntil = -1f;

		private bool _domainDealsDamage;

		private bool _domainAudioLoading;

		private AudioClip _domainAudioClip;

		private GameObject _domainAudioObject;

		private AudioSource _domainAudioSource;

		private float _nextDomainAudioWarningAt;

		private readonly Dictionary<string, AudioClip> _gojoAudioClips = new Dictionary<string, AudioClip>(StringComparer.OrdinalIgnoreCase);

		private GameObject _gojoDomainAudioObject;

		private float _nextGojoAudioWarningAt;

		private AudioClip _yujiDivergentFirstClip;

		private AudioClip _yujiDivergentDelayedClip;

		private AudioClip _yujiBlackFlashClip;

		private float _nextSukunaDomain;

		private float _nextDomainSlashAt;

		private float _nextDomainNetworkSyncAt;

		private int _domainSlashIndex;

		private int _domainBeatIndex;

		private bool _domainBeatHasTarget;

		private Vector3 _domainBeatTargetPoint;

		private RigManager _domainBeatTargetRig;

		private Collider _domainBeatTargetCollider;

		private readonly List<DomainPlayerTarget> _domainPlayerTargets = new List<DomainPlayerTarget>();

		private readonly List<DomainSlashVisual> _domainSlashPool = new List<DomainSlashVisual>();

		private int _domainSlashPoolCursor;

		private readonly List<DomainCastRecord> _recentDomainCasts = new List<DomainCastRecord>();

		private readonly Dictionary<byte, DomainClashParticipant> _domainClashParticipants = new Dictionary<byte, DomainClashParticipant>();

		private GameObject _domainClashRoot;

		private Vector3 _domainClashCenter;

		private float _domainClashStartedAt = -1f;

		private float _domainClashUntil = -1f;

		private float _nextDomainClashStatusAt;

		private bool _domainClashActive;

		private bool _domainClashResolved;

		private bool _homelanderFlightActive;

		private float _homelanderFlightUntil = -1f;

		private float _homelanderFlightSpeedMultiplier = 1f;

		private Vector3 _homelanderFlightVelocity;

		private Rigidbody[] _flightBodies = Array.Empty<Rigidbody>();

		private float[] _flightSavedDrags = Array.Empty<float>();

		private bool[] _flightSavedGravity = Array.Empty<bool>();

		private bool _dashEnabled = true;

		private float _dashBaseSpeed = 20f;

		private bool _dashAccelerationEnabled;

		private float _dashAccelerationIncrement = 5f;

		private float _dashCurrentSpeed = 20f;

		private float _dashLastDashTime;

		private float _nextDashReadyAt;

		private DashHandSide _dashHand = DashHandSide.Left;

		private bool _dashAutoLockOnEnabled;

		private bool _dashRandomTargetEnabled;

		private float _dashRandomTargetInterval = 5f;

		private float _dashLastRandomTargetTime;

		private ulong? _dashTargetPlayerId;

		private string _dashTargetDisplayName = "None";

		private DashTargetPart _dashTargetPart = DashTargetPart.Pelvis;

		private bool _dashAutoDashTriggerEnabled;

		private float _dashAutoDashInterval = 0.05f;

		private bool _dashIsAutoDashing;

		private float _dashLastAutoDashTime;

		private bool _dashPhaseModeEnabled;

		private bool _dashIsPhasing;

		private bool _dashWasStickDown;

		private readonly Dictionary<long, bool> _dashInitialLayerCollisionStates = new Dictionary<long, bool>();

		private AssetBundle _limitlessCtBundle;

		private GameObject _limitlessCtRedOverchargePrefab;

		private GameObject _limitlessCtRedMaxExplosionPrefab;

		private GameObject _limitlessCtBluePrefab;

		private GameObject _limitlessCtBlueOverchargePrefab;

		private GameObject _limitlessCtInfiniteVoidPrefab;

		private bool _limitlessCtBundleLoadAttempted;

		private float _nextLimitlessCtWarningAt;

		private AssetBundle _cursedEnergySystemBundle;

		private GameObject _cursedEnergyImpactPrefab;

		private bool _cursedEnergySystemBundleLoadAttempted;

		private float _nextCursedEnergyWarningAt;

		private AssetBundle _bloodManipulationBundle;

		private AssetBundle _bloodManipulationShadersBundle;

		private GameObject _bloodManipulationPiercingBloodPrefab;

		private bool _bloodManipulationBundleLoadAttempted;

		private float _nextBloodManipulationWarningAt;

		private AssetBundle _sukunaTechniqueBundle;

		private AssetBundle _sukunaTechniqueShadersBundle;

		private GameObject _sukunaTechniqueShrinePrefab;

		private GameObject _sukunaTechniqueFugaPrefab;

		private bool _sukunaTechniqueBundleLoadAttempted;

		private float _nextSukunaTechniqueWarningAt;

		private AssetBundle _shrineTechBundle;

		private AssetBundle _shrineTechShadersBundle;

		private GameObject _shrineTechCleaveWebPrefab;

		private GameObject _shrineTechDismantleNetPrefab;

		private AudioClip _shrineTechDismantleSoundClip;

		private bool _shrineTechDismantleSoundLoadAttempted;

		private bool _shrineTechBundleLoadAttempted;

		private float _nextShrineTechWarningAt;

		private AssetBundle _homoShrineBundle;

		private AssetBundle _homoShrineShadersBundle;

		private VisualEffectAsset _homoShrineDismantleVfx;

		private VisualEffectAsset _homoShrineStrongDismantleVfx;

		private bool _homoShrineBundleLoadAttempted;

		private float _nextHomoShrineWarningAt;

		private readonly Dictionary<int, FrozenBodyState> _gojoFrozenBodies = new Dictionary<int, FrozenBodyState>();

		private bool _pvpCharacterSelected;

		private bool _bodyLogSuppressed;

		private float _nextBodyLogSuppressAt;

		private float _pvpMoveLockedUntil;

		private int _localCriticalStacks;

		private bool _pvpHealthTrackerReady;

		private float _pvpTrackedHealth;

		private bool _suppressDomainClashScore;

		private int _selectionResetSerial;

		internal static PVPMultiversalMod Instance { get; private set; }

		public override void OnInitializeMelon()
		{
			Instance = this;
			ClassInjector.RegisterTypeInIl2Cpp<PositionOnlyHandFollower>();
			ClassInjector.RegisterTypeInIl2Cpp<LocalRigCollisionIgnorer>();
			ClassInjector.RegisterTypeInIl2Cpp<LocalRigExplosionVelocityDamper>();
			ClassInjector.RegisterTypeInIl2Cpp<HeadMountedFollower>();
			ClassInjector.RegisterTypeInIl2Cpp<ReversalRedHandFollower>();
			ClassInjector.RegisterTypeInIl2Cpp<ReversalRedAnimationStabilizer>();
			ClassInjector.RegisterTypeInIl2Cpp<ReversalRedProxyAnimator>();
			ClassInjector.RegisterTypeInIl2Cpp<ReversalRedExplosionDamageDealer>();
			ClassInjector.RegisterTypeInIl2Cpp<ReversalRedRemoteLocalDamageDealer>();
			ClassInjector.RegisterTypeInIl2Cpp<LimitlessCtDelayedVisualSpawner>();
			ClassInjector.RegisterTypeInIl2Cpp<GojoBlueWell>();
			ClassInjector.RegisterTypeInIl2Cpp<GojoBlueSelfPull>();
			ClassInjector.RegisterTypeInIl2Cpp<GojoBlueAnimator>();
			ClassInjector.RegisterTypeInIl2Cpp<GojoDomainFreezeField>();
			ClassInjector.RegisterTypeInIl2Cpp<TojiPlayfulCloudDamageLimiter>();
			ClassInjector.RegisterTypeInIl2Cpp<BloodManipulationLiquidStreamVisual>();
			RegisterNetworkMessages();
			PreloadSukunaUltimateAudio();
			PreloadSukunaDomainAudio();
			PreloadGojoAudio();
			PatchPunchHook();
			SetupBoneMenu();
			MelonLogger.Msg("PVP Multiversal loaded.");
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			RestoreStatsBoost();
			_rigManager = null;
			_physicsRig = null;
			_kitMode = KitMode.None;
			_statsSnapshot = null;
			_pendingHomelanderV1Stats = false;
			_ultimateEndsAt = -1f;
			StopLaserEyes(updateStatus: false);
			StopHomelanderFlight();
			DestroySukunaDomain();
			DestroyGojoDomain();
			DestroyDomainClash();
			ClearGojoFrozenBodies();
			ClearBonelabShrineMaterials();
			ClearRemoteLasers();
			ClearRemoteBloodManipulation();
			_laserEyesObject = null;
			_laserComponentLogDone = false;
			_laserEyesLoading = false;
			_domainAudioLoading = false;
			_pvpCharacterSelected = false;
			_localCriticalStacks = 0;
			_pvpHealthTrackerReady = false;
			_pvpTrackedHealth = 0f;
			_bodyLogSuppressed = false;
			_nextBodyLogSuppressAt = 0f;
			SetDashPhasing(active: false);
			_dashIsAutoDashing = false;
			_dashWasStickDown = false;
			_nextDashReadyAt = 0f;
			ResetInputState();
			_lastStatus = "Ready";
			_menuRebuildPending = true;
		}

		public override void OnDeinitializeMelon()
		{
			RestoreStatsBoost();
			SetDashPhasing(active: false);
			ClearGojoFrozenBodies();
			if ((Object)(object)_limitlessCtBundle != (Object)null)
			{
				_limitlessCtBundle.Unload(false);
				_limitlessCtBundle = null;
				_limitlessCtRedOverchargePrefab = null;
				_limitlessCtRedMaxExplosionPrefab = null;
				_limitlessCtBluePrefab = null;
				_limitlessCtBlueOverchargePrefab = null;
				_limitlessCtInfiniteVoidPrefab = null;
			}
			if ((Object)(object)_cursedEnergySystemBundle != (Object)null)
			{
				_cursedEnergySystemBundle.Unload(false);
				_cursedEnergySystemBundle = null;
				_cursedEnergyImpactPrefab = null;
			}
			if ((Object)(object)_bloodManipulationBundle != (Object)null)
			{
				_bloodManipulationBundle.Unload(false);
				_bloodManipulationBundle = null;
				_bloodManipulationPiercingBloodPrefab = null;
			}
			if ((Object)(object)_bloodManipulationShadersBundle != (Object)null)
			{
				_bloodManipulationShadersBundle.Unload(false);
				_bloodManipulationShadersBundle = null;
			}
			if ((Object)(object)_sukunaTechniqueBundle != (Object)null)
			{
				_sukunaTechniqueBundle.Unload(false);
				_sukunaTechniqueBundle = null;
				_sukunaTechniqueShrinePrefab = null;
				_sukunaTechniqueFugaPrefab = null;
			}
			if ((Object)(object)_sukunaTechniqueShadersBundle != (Object)null)
			{
				_sukunaTechniqueShadersBundle.Unload(false);
				_sukunaTechniqueShadersBundle = null;
			}
		}

		public override void OnUpdate()
		{
			if (_menuRebuildPending)
			{
				_menuRebuildPending = false;
				SetupBoneMenu();
			}
			if (!TryResolveRig())
			{
				ResetInputState();
				CacheInputState();
				return;
			}
			MaintainTimedModes();
			PollManualInputs();
			ProcessKitInputs();
			MaintainDashAcceleration();
			MaintainSukunaDomain();
			MaintainDomainClash();
			MaintainPvpHealthRegeneration();
			MaintainRemoteLasers();
			MaintainRemoteBloodManipulation();
			MaintainBodyLogSuppression();
			CacheInputState();
		}

		public override void OnFixedUpdate()
		{
			MaintainHomelanderFlight();
			MaintainLaserEyesDamage();
			MaintainGojoFrozenBodies();
		}

		private void RegisterNetworkMessages()
		{
			try
			{
				ModuleMessageManager.RegisterHandler(typeof(PVPMultiversalMessageHandler));
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("PVP Multiversal network sync skipped: " + ex.Message);
			}
		}

		private void SetupBoneMenu()
		{
			//IL_0042: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			if (Page.Root == null)
			{
				_menuRebuildPending = true;
				return;
			}
			if (_mainPage == null)
			{
				_mainPage = Page.Root.CreatePage("PVP Multiversal", new Color(0.85f, 0.15f, 1f), 0, true);
			}
			else
			{
				_mainPage.RemoveAll();
			}
			RosterAvatar[] roster = Roster;
			foreach (RosterAvatar rosterAvatar in roster)
			{
				RosterAvatar captured = rosterAvatar;
				_mainPage.CreateFunction(captured.DisplayName, captured.Color, (Action)delegate
				{
					SelectAvatar(captured);
				});
			}
			_mainPage.CreateFunction("Set Yuji Ultimate 5s", Color.red, (Action)TestYujiUltimate);
			_mainPage.CreateFunction("Set Sukuna Ultimate 5s", new Color(0.85f, 0.05f, 0.05f), (Action)TestSukunaUltimate);
			_mainPage.CreateFunction("Set Gojo Ultimate 5s", new Color(0.45f, 0.65f, 1f), (Action)TestGojoUltimate);
			_mainPage.CreateFunction("Preview Shrine Visual", new Color(0.95f, 0.16f, 0.08f), (Action)PreviewSukunaShrine);
			_kitPage = _mainPage.CreatePage("Character Kit", Color.red, 0, true);
			PopulateKitPage();
			_dashPage = null;
			_dashPlayersPage = null;
			_mainPage.CreateFunction("Status: " + _lastStatus, Color.white, (Action)delegate
			{
			});
		}

		private void PopulateKitPage()
		{
			//IL_0036: 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)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			if (_kitPage == null)
			{
				return;
			}
			_kitPage.CreateFunction("Mode: " + _kitMode, ModeColor(), (Action)delegate
			{
			});
			_kitPage.CreateFunction("Y x2: " + GetYDoubleTapText(), Color.yellow, (Action)delegate
			{
			});
			_kitPage.CreateFunction("B x2: " + GetBDoubleTapText(), Color.magenta, (Action)delegate
			{
			});
			_kitPage.CreateFunction("B + Y: " + GetFaceComboText(), Color.cyan, (Action)delegate
			{
			});
			_kitPage.CreateFunction("Punch: " + GetPunchText(), Color.red, (Action)delegate
			{
			});
			_kitPage.CreateFunction("Right Stick: " + GetRightStickText(), Color.cyan, (Action)delegate
			{
			});
			_kitPage.CreateFunction("Critical Hits: " + GetLocalCriticalText(), new Color(1f, 0.45f, 0.05f), (Action)delegate
			{
			});
			if (_kitMode == KitMode.Gojo)
			{
				_kitPage.CreateBool("Punch Black Flash", new Color(0.35f, 0.75f, 1f), _gojoBlackFlashPunchEnabled, (Action<bool>)delegate(bool value)
				{
					_gojoBlackFlashPunchEnabled = value;
					SetStatus(value ? "Gojo punch Black Flash on" : "Gojo punch Black Flash off");
				});
			}
			_kitPage.CreateFunction("Set Yuji Ultimate 5s", Color.red, (Action)TestYujiUltimate);
			_kitPage.CreateFunction("Set Sukuna Ultimate 5s", new Color(0.85f, 0.05f, 0.05f), (Action)TestSukunaUltimate);
			_kitPage.CreateFunction("Set Gojo Ultimate 5s", new Color(0.45f, 0.65f, 1f), (Action)TestGojoUltimate);
			_kitPage.CreateFunction("Preview Shrine Visual", new Color(0.95f, 0.16f, 0.08f), (Action)PreviewSukunaShrine);
			_kitPage.CreateFunction("Status: " + _lastStatus, Color.white, (Action)delegate
			{
			});
		}

		private void PopulateDashPage()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			if (_dashPage == null)
			{
				return;
			}
			_dashPage.CreateBool("Enabled", Color.green, _dashEnabled, (Action<bool>)delegate(bool value)
			{
				_dashEnabled = value;
				if (!value)
				{
					_dashIsAutoDashing = false;
					SetDashPhasing(active: false);
				}
			});
			_dashPage.CreateFloat("Base Speed", Color.blue, _dashBaseSpeed, 1f, 0f, float.MaxValue, (Action<float>)delegate(float value)
			{
				_dashBaseSpeed = Mathf.Max(0f, value);
				if (!_dashAccelerationEnabled)
				{
					_dashCurrentSpeed = _dashBaseSpeed;
				}
			});
			_dashPage.CreateBool("Phase Mode", Color.red, _dashPhaseModeEnabled, (Action<bool>)delegate(bool value)
			{
				_dashPhaseModeEnabled = value;
				if (!value)
				{
					SetDashPhasing(active: false);
				}
			});
			Page val = _dashPage.CreatePage("Acceleration", Color.yellow, 0, true);
			val.CreateBool("Enable Acceleration", Color.green, _dashAccelerationEnabled, (Action<bool>)delegate(bool value)
			{
				_dashAccelerationEnabled = value;
				_dashCurrentSpeed = _dashBaseSpeed;
			});
			val.CreateFloat("Increment Amount", Color.white, _dashAccelerationIncrement, 1f, 0f, float.MaxValue, (Action<float>)delegate(float value)
			{
				_dashAccelerationIncrement = Mathf.Max(0f, value);
			});
			_dashPage.CreateEnum("Thumbstick", Color.white, (Enum)_dashHand, (Action<Enum>)delegate(Enum value)
			{
				_dashHand = (DashHandSide)(object)value;
				_dashWasStickDown = false;
			});
			Page val2 = _dashPage.CreatePage("Auto Lock-on", Color.red, 0, true);
			val2.CreateBool("Enable Lock-on", Color.green, _dashAutoLockOnEnabled, (Action<bool>)delegate(bool value)
			{
				_dashAutoLockOnEnabled = value;
			});
			val2.CreateBool("Random Target Mode", new Color(1f, 0.5f, 0f), _dashRandomTargetEnabled, (Action<bool>)delegate(bool value)
			{
				_dashRandomTargetEnabled = value;
			});
			val2.CreateFloat("Random Target Interval", Color.white, _dashRandomTargetInterval, 0.25f, 0.25f, 60f, (Action<float>)delegate(float value)
			{
				_dashRandomTargetInterval = Mathf.Max(0.25f, value);
			});
			val2.CreateEnum("Target Part", Color.yellow, (Enum)_dashTargetPart, (Action<Enum>)delegate(Enum value)
			{
				_dashTargetPart = (DashTargetPart)(object)value;
			});
			val2.CreateFunction("Target: " + _dashTargetDisplayName, Color.cyan, (Action)delegate
			{
			});
			_dashPlayersPage = val2.CreatePage("Players", Color.white, 0, true);
			PopulateDashPlayersPage();
			Page val3 = _dashPage.CreatePage("Auto Dash", Color.magenta, 0, true);
			val3.CreateBool("Auto Dash Trigger", Color.green, _dashAutoDashTriggerEnabled, (Action<bool>)delegate(bool value)
			{
				_dashAutoDashTriggerEnabled = value;
				if (!value)
				{
					_dashIsAutoDashing = false;
				}
			});
			val3.CreateFloat("Auto Dash Interval", Color.white, _dashAutoDashInterval, 0.01f, 0.01f, 2f, (Action<float>)delegate(float value)
			{
				_dashAutoDashInterval = Mathf.Max(0.01f, value);
			});
		}

		private void PopulateDashPlayersPage()
		{
			//IL_001