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.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.BoneMenu.UI;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Bonelab;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Pool;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSLZ.VRMK;
using Il2CppSystem;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using LabFusion.Entities;
using LabFusion.Marrow.Integration;
using LabFusion.Player;
using LabFusion.SDK.Cosmetics;
using LabFusion.SDK.Points;
using LocalMirrorMod;
using LocalMirrorMod.Fixes;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LocalMirror")]
[assembly: AssemblyDescription("Standalone Local Mirror mod for BONELAB")]
[assembly: AssemblyProduct("LocalMirror")]
[assembly: AssemblyCopyright("Copyright 2026")]
[assembly: ComVisible(false)]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: MelonInfo(typeof(Main), "LocalMirror", "1.0.0", "MrYetiSpaghetti", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: MelonPriority(-230)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LocalMirrorMod
{
	public static class Config
	{
		private const string CategoryId = "LocalMirror";

		public static MelonPreferences_Category _category;

		public static MelonPreferences_Entry<float> MirrorDistance;

		public static MelonPreferences_Entry<bool> MirrorScaleByHeight;

		public static MelonPreferences_Entry<bool> MirrorFollowHead;

		public static MelonPreferences_Entry<bool> MirrorStayInPlace;

		public static MelonPreferences_Entry<bool> LocalMirrorHeldItemAwarenessEnabled;

		public static MelonPreferences_Entry<bool> LocalMirrorSeatAwarenessEnabled;

		public static MelonPreferences_Entry<bool> LocalMirrorProximityAwarenessEnabled;

		public static MelonPreferences_Entry<float> LocalMirrorProximityRadius;

		public static MelonPreferences_Entry<bool> LocalMirrorProximityVisualEnabled;

		public static MelonPreferences_Entry<bool> LocalMirrorIncludeOthersEnabled;

		public static MelonPreferences_Entry<bool> LocalMirrorShowHolsteredEnabled;

		public static MelonPreferences_Entry<bool> ShowFusionCosmeticsEnabled;

		private static BoolElement _localMirrorToggleElement;

		private static BoolElement _mirrorScaleByHeightElement;

		private static BoolElement _mirrorFollowHeadElement;

		private static BoolElement _mirrorStayInPlaceElement;

		private static BoolElement _showHolsteredElement;

		private static BoolElement _heldItemAwarenessElement;

		private static BoolElement _seatAwarenessElement;

		private static BoolElement _proximityAwarenessElement;

		private static BoolElement _proximityVisualElement;

		private static BoolElement _includeOthersElement;

		private static BoolElement _showFusionCosmeticsElement;

		public static void Initialize()
		{
			_category = MelonPreferences.CreateCategory("LocalMirror");
			_category.SetFilePath("UserData/LocalMirror.cfg", true, false);
			MirrorDistance = _category.CreateEntry<float>("MirrorDistance", 1.5f, "Distance in meters from the player chest to the mirror clone", (string)null, false, false, (ValueValidator)null, (string)null);
			MirrorScaleByHeight = _category.CreateEntry<bool>("MirrorScaleByHeight", true, "Scale the mirror distance proportionally to the player's avatar height", (string)null, false, false, (ValueValidator)null, (string)null);
			MirrorFollowHead = _category.CreateEntry<bool>("MirrorFollowHead", false, "Mirror tracks head facing live; when off, facing direction is frozen at enable time", (string)null, false, false, (ValueValidator)null, (string)null);
			MirrorStayInPlace = _category.CreateEntry<bool>("MirrorStayInPlace", false, "Spawn the mirror once at correct distance facing the player, then keep it stationary", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorHeldItemAwarenessEnabled = _category.CreateEntry<bool>("HeldItemAwareness", true, "Mirror whichever spawnable the player's hand is currently grabbing onto the clone", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorSeatAwarenessEnabled = _category.CreateEntry<bool>("SeatAwareness", true, "Mirror the vehicle / seat the player is sitting in onto the clone", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorProximityAwarenessEnabled = _category.CreateEntry<bool>("ProximityAwareness", false, "Mirror any spawnable inside the configured radius of the player onto the clone", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorProximityRadius = _category.CreateEntry<float>("ProximityRadius", 2f, "Proximity Awareness radius in meters", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorProximityVisualEnabled = _category.CreateEntry<bool>("ProximityVisual", true, "Render a white circle ring at the proximity radius around the player", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorIncludeOthersEnabled = _category.CreateEntry<bool>("IncludeOthers", false, "Include other players' rigs as eligible for the LocalMirror item awareness toggles (held / proximity)", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirrorShowHolsteredEnabled = _category.CreateEntry<bool>("ShowHolstered", true, "Show holstered items on the LocalMirror clone (and on remote rig clones when Include Others is on)", (string)null, false, false, (ValueValidator)null, (string)null);
			ShowFusionCosmeticsEnabled = _category.CreateEntry<bool>("ShowFusionCosmetics", false, "Mirror the local player's equipped Fusion cosmetics (and remote players' when Include Others is on) onto the mirror clones", (string)null, false, false, (ValueValidator)null, (string)null);
			LocalMirror.Distance = MirrorDistance.Value;
			LocalMirror.ScaleByAvatarHeight = MirrorScaleByHeight.Value;
			LocalMirror.FollowHead = MirrorFollowHead.Value;
			LocalMirror.StayInPlace = MirrorStayInPlace.Value;
			BuildBoneMenu();
		}

		private static void BuildBoneMenu()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			Color endColor = default(Color);
			((Color)(ref endColor))..ctor(0.75f, 0.75f, 0.75f, 1f);
			Page val2 = Page.Root.CreatePage(BuildGradientText("LocalMirror", Color.white, endColor), Color.white, 0, true);
			BoneMenuScrollClamp.Register(val2);
			BoneMenuScrollButtons.Register(val2);
			_localMirrorToggleElement = val2.CreateBool("Local Mirror", Color.green, LocalMirror.Enabled, (Action<bool>)delegate(bool val)
			{
				if (val)
				{
					LocalMirror.Enable();
				}
				else
				{
					LocalMirror.Disable();
				}
			});
			try
			{
				LocalMirror.OnEnabledChanged += delegate(bool newState)
				{
					try
					{
						if (_localMirrorToggleElement != null)
						{
							_localMirrorToggleElement.Value = newState;
						}
					}
					catch
					{
					}
				};
			}
			catch
			{
			}
			MenuSliderHelper.RegisterSliderWithType(val2, "Mirror Distance", MirrorDistance.Value, 0.1f, 0.3f, 3f, delegate(float val)
			{
				MirrorDistance.Value = val;
				_category.SaveToFile(false);
				LocalMirror.Distance = val;
			});
			_mirrorScaleByHeightElement = val2.CreateBool("Distance scales with height", Color.green, MirrorScaleByHeight.Value, (Action<bool>)delegate(bool val)
			{
				MirrorScaleByHeight.Value = val;
				_category.SaveToFile(false);
				LocalMirror.ScaleByAvatarHeight = val;
			});
			_mirrorFollowHeadElement = val2.CreateBool("Mirror follows head", Color.green, MirrorFollowHead.Value, (Action<bool>)delegate(bool val)
			{
				MirrorFollowHead.Value = val;
				_category.SaveToFile(false);
				LocalMirror.FollowHead = val;
			});
			_mirrorStayInPlaceElement = val2.CreateBool("Mirror stays in place", Color.green, MirrorStayInPlace.Value, (Action<bool>)delegate(bool val)
			{
				MirrorStayInPlace.Value = val;
				_category.SaveToFile(false);
				LocalMirror.StayInPlace = val;
			});
			_showHolsteredElement = val2.CreateBool("Show Holstered Items", Color.green, LocalMirrorShowHolsteredEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorShowHolsteredEnabled.Value = val;
				_category.SaveToFile(false);
			});
			_heldItemAwarenessElement = val2.CreateBool("Held Item Awareness", Color.green, LocalMirrorHeldItemAwarenessEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorHeldItemAwarenessEnabled.Value = val;
				_category.SaveToFile(false);
			});
			_seatAwarenessElement = val2.CreateBool("Seat Awareness", Color.green, LocalMirrorSeatAwarenessEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorSeatAwarenessEnabled.Value = val;
				_category.SaveToFile(false);
			});
			_proximityAwarenessElement = val2.CreateBool("Proximity Awareness", Color.green, LocalMirrorProximityAwarenessEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorProximityAwarenessEnabled.Value = val;
				_category.SaveToFile(false);
			});
			MenuSliderHelper.RegisterSliderWithType(val2, "Proximity Radius (m)", LocalMirrorProximityRadius.Value, 0.1f, 0.1f, 30f, delegate(float val)
			{
				LocalMirrorProximityRadius.Value = val;
				_category.SaveToFile(false);
			});
			_proximityVisualElement = val2.CreateBool("Proximity Visual", Color.green, LocalMirrorProximityVisualEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorProximityVisualEnabled.Value = val;
				_category.SaveToFile(false);
			});
			_includeOthersElement = val2.CreateBool("Include Others", Color.green, LocalMirrorIncludeOthersEnabled.Value, (Action<bool>)delegate(bool val)
			{
				LocalMirrorIncludeOthersEnabled.Value = val;
				_category.SaveToFile(false);
			});
			_showFusionCosmeticsElement = val2.CreateBool("Show Fusion Cosmetics", Color.green, ShowFusionCosmeticsEnabled.Value, (Action<bool>)delegate(bool val)
			{
				ShowFusionCosmeticsEnabled.Value = val;
				_category.SaveToFile(false);
			});
			val2.CreateFunction("Reset To Default", Color.red, (Action)ResetAllTogglesToDefault);
		}

		private static void ResetAllTogglesToDefault()
		{
			try
			{
				LocalMirror.Disable();
			}
			catch
			{
			}
			ApplySliderPref(MirrorDistance, 1.5f);
			LocalMirror.Distance = 1.5f;
			MenuSliderHelper.ResetSlider("Mirror Distance", 1.5f);
			ApplyBoolDefault(_mirrorScaleByHeightElement, MirrorScaleByHeight, defaultValue: true, delegate
			{
				LocalMirror.ScaleByAvatarHeight = true;
			}, delegate
			{
				LocalMirror.ScaleByAvatarHeight = false;
			});
			ApplyBoolDefault(_mirrorFollowHeadElement, MirrorFollowHead, defaultValue: false, delegate
			{
				LocalMirror.FollowHead = true;
			}, delegate
			{
				LocalMirror.FollowHead = false;
			});
			ApplyBoolDefault(_mirrorStayInPlaceElement, MirrorStayInPlace, defaultValue: false, delegate
			{
				LocalMirror.StayInPlace = true;
			}, delegate
			{
				LocalMirror.StayInPlace = false;
			});
			ApplyBoolDefault(_showHolsteredElement, LocalMirrorShowHolsteredEnabled, defaultValue: true, null, null);
			ApplyBoolDefault(_heldItemAwarenessElement, LocalMirrorHeldItemAwarenessEnabled, defaultValue: true, null, null);
			ApplyBoolDefault(_seatAwarenessElement, LocalMirrorSeatAwarenessEnabled, defaultValue: true, null, null);
			ApplyBoolDefault(_proximityAwarenessElement, LocalMirrorProximityAwarenessEnabled, defaultValue: false, null, null);
			ApplySliderPref(LocalMirrorProximityRadius, 2f);
			MenuSliderHelper.ResetSlider("Proximity Radius (m)", 2f);
			ApplyBoolDefault(_proximityVisualElement, LocalMirrorProximityVisualEnabled, defaultValue: true, null, null);
			ApplyBoolDefault(_includeOthersElement, LocalMirrorIncludeOthersEnabled, defaultValue: false, null, null);
			ApplyBoolDefault(_showFusionCosmeticsElement, ShowFusionCosmeticsEnabled, defaultValue: false, null, null);
			_category.SaveToFile(false);
		}

		private static void ApplyBoolDefault(BoolElement element, MelonPreferences_Entry<bool> pref, bool defaultValue, Action apply, Action revert)
		{
			if (pref != null)
			{
				pref.Value = defaultValue;
			}
			if (element != null)
			{
				element.Value = defaultValue;
			}
			try
			{
				if (defaultValue)
				{
					apply?.Invoke();
				}
				else
				{
					revert?.Invoke();
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] Reset toggle apply failed: " + ex.Message);
			}
		}

		private static void ApplySliderPref(MelonPreferences_Entry<float> pref, float defaultValue)
		{
			if (pref != null)
			{
				pref.Value = defaultValue;
			}
		}

		private static string BuildGradientText(string text, Color startColor, Color endColor)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length * 22);
			int length = text.Length;
			for (int i = 0; i < length; i++)
			{
				float num = ((length > 1) ? ((float)i / (float)(length - 1)) : 0f);
				Color val = Color.Lerp(startColor, endColor, num);
				int num2 = Mathf.Clamp((int)(val.r * 255f), 0, 255);
				int num3 = Mathf.Clamp((int)(val.g * 255f), 0, 255);
				int num4 = Mathf.Clamp((int)(val.b * 255f), 0, 255);
				stringBuilder.Append("<color=#").Append(num2.ToString("X2")).Append(num3.ToString("X2"))
					.Append(num4.ToString("X2"))
					.Append('>')
					.Append(text[i])
					.Append("</color>");
			}
			return stringBuilder.ToString();
		}
	}
	public class Main : MelonMod
	{
		public const string Version = "1.0.0";

		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("LocalMirror v1.0.0 loading...");
			Config.Initialize();
			Hooking.OnLevelLoaded += OnLevelLoaded;
			Hooking.OnSwitchAvatarPostfix += OnAvatarChanged;
			((MelonBase)this).LoggerInstance.Msg("LocalMirror v1.0.0 loaded!");
		}

		public override void OnUpdate()
		{
			try
			{
				LocalMirror.OnUpdate();
			}
			catch
			{
			}
			try
			{
				RadialToggle.OnUpdate();
			}
			catch
			{
			}
			try
			{
				BoneMenuScrollClamp.OnUpdate();
			}
			catch
			{
			}
			try
			{
				MenuSliderHelper.OnUpdate();
			}
			catch
			{
			}
		}

		public override void OnFixedUpdate()
		{
		}

		public override void OnLateUpdate()
		{
			try
			{
				LocalMirror.LateEnforce();
			}
			catch
			{
			}
		}

		private static void OnLevelLoaded(LevelInfo levelInfo)
		{
			try
			{
				LocalMirror.OnLevelLoaded();
			}
			catch
			{
			}
			try
			{
				RadialToggle.OnLevelLoaded();
			}
			catch
			{
			}
		}

		private static void OnAvatarChanged(Avatar avatar)
		{
			try
			{
				LocalMirror.OnAvatarChanged(avatar);
			}
			catch
			{
			}
		}
	}
}
namespace LocalMirrorMod.Fixes
{
	public static class BoneMenuScrollButtons
	{
		private static Page _page;

		private static GameObject _navContainer;

		private static Sprite _fillSprite;

		private static Sprite _borderSprite;

		public static void Register(Page page)
		{
			_page = page;
			Menu.OnPageOpened += OnPageOpened;
		}

		private static void OnPageOpened(Page page)
		{
			if (page == _page)
			{
				if ((Object)(object)_navContainer == (Object)null)
				{
					CreateNavButtons();
				}
				if ((Object)(object)_navContainer != (Object)null)
				{
					_navContainer.SetActive(true);
				}
			}
			else if ((Object)(object)_navContainer != (Object)null)
			{
				_navContainer.SetActive(false);
			}
		}

		private static void CreateNavButtons()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Unknown result type (might be due to invalid IL or missing references)
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GUIMenu instance = GUIMenu.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				Transform val = ((Component)instance).transform.Find("Page/Content");
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Transform val2 = val.Find("Interaction");
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				Transform val3 = val2.Find("ScrollUp");
				Transform val4 = val2.Find("ScrollDown");
				if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					return;
				}
				Transform val5 = val.Find("Viewport");
				ScrollRect scrollRect = (((Object)(object)val5 != (Object)null) ? ((Component)val5).GetComponent<ScrollRect>() : null);
				if ((Object)(object)scrollRect == (Object)null)
				{
					return;
				}
				TMP_FontAsset val6 = null;
				TextMeshProUGUI componentInChildren = ((Component)val).GetComponentInChildren<TextMeshProUGUI>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					val6 = ((TMP_Text)componentInChildren).font;
				}
				RectTransform component = ((Component)val3).GetComponent<RectTransform>();
				RectTransform component2 = ((Component)val4).GetComponent<RectTransform>();
				float y = component.anchoredPosition.y;
				float y2 = component2.anchoredPosition.y;
				float num = component.sizeDelta.y;
				float num2 = component.sizeDelta.x;
				if (num2 < 1f)
				{
					num2 = 40f;
				}
				if (num < 1f)
				{
					num = 40f;
				}
				EnsureSprites();
				float num3 = (y + y2) / 2f;
				float num4 = y - num * component.pivot.y;
				float num5 = y2 + num * (1f - component2.pivot.y);
				float num6 = Mathf.Abs(num4 - num5);
				float num7 = 2f;
				float num8 = num2 * 6f;
				_navContainer = new GameObject("LocalMirror_NavButtons");
				_navContainer.transform.SetParent(val2, false);
				RectTransform obj = _navContainer.AddComponent<RectTransform>();
				obj.anchorMin = component.anchorMin;
				obj.anchorMax = component.anchorMax;
				obj.pivot = new Vector2(0.5f, 0.5f);
				obj.anchoredPosition = new Vector2(component.anchoredPosition.x, num3);
				obj.sizeDelta = new Vector2(num8, num6);
				VerticalLayoutGroup obj2 = _navContainer.AddComponent<VerticalLayoutGroup>();
				((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = true;
				((HorizontalOrVerticalLayoutGroup)obj2).spacing = num7;
				string[] array = new string[5] { "Top", "Upper", "Middle", "Lower", "Bottom" };
				float[] array2 = new float[5] { 0f, 0.25f, 0.5f, 0.75f, 1f };
				GameObject gameObject = ((Component)val3).gameObject;
				for (int i = 0; i < 5; i++)
				{
					float num9 = array2[i];
					string text = array[i];
					GameObject val7 = Object.Instantiate<GameObject>(gameObject, _navContainer.transform);
					((Object)val7).name = text;
					val7.transform.localRotation = Quaternion.identity;
					LayoutElement component3 = val7.GetComponent<LayoutElement>();
					if ((Object)(object)component3 != (Object)null)
					{
						Object.Destroy((Object)(object)component3);
					}
					BoxCollider component4 = val7.GetComponent<BoxCollider>();
					if ((Object)(object)component4 != (Object)null)
					{
						float num10 = (num6 - num7 * 4f) / 5f;
						component4.size = new Vector3(num8, num10, component4.size.z);
						component4.center = Vector3.zero;
					}
					Button component5 = val7.GetComponent<Button>();
					if ((Object)(object)component5 != (Object)null)
					{
						((UnityEventBase)component5.onClick).RemoveAllListeners();
						float capturedFrac = num9;
						((UnityEvent)component5.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							//IL_001c: Unknown result type (might be due to invalid IL or missing references)
							//IL_0031: Unknown result type (might be due to invalid IL or missing references)
							scrollRect.normalizedPosition = new Vector2(0f, 1f - capturedFrac);
							scrollRect.velocity = Vector2.zero;
						}));
						ColorBlock colors = ((Selectable)component5).colors;
						((ColorBlock)(ref colors)).normalColor = new Color(1f, 1f, 1f, 0.06f);
						((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 0.25f);
						((ColorBlock)(ref colors)).pressedColor = new Color(1f, 1f, 1f, 1f);
						((ColorBlock)(ref colors)).selectedColor = new Color(1f, 1f, 1f, 0.06f);
						((ColorBlock)(ref colors)).colorMultiplier = 1f;
						((ColorBlock)(ref colors)).fadeDuration = 0.08f;
						((Selectable)component5).colors = colors;
					}
					for (int num11 = val7.transform.childCount - 1; num11 >= 0; num11--)
					{
						Object.Destroy((Object)(object)((Component)val7.transform.GetChild(num11)).gameObject);
					}
					Image component6 = val7.GetComponent<Image>();
					if ((Object)(object)component6 != (Object)null)
					{
						if ((Object)(object)_fillSprite != (Object)null)
						{
							component6.sprite = _fillSprite;
							component6.type = (Type)1;
						}
						((Graphic)component6).color = Color.white;
						((Graphic)component6).raycastTarget = true;
					}
					GameObject val8 = new GameObject("Border");
					val8.transform.SetParent(val7.transform, false);
					RectTransform obj3 = val8.AddComponent<RectTransform>();
					obj3.anchorMin = Vector2.zero;
					obj3.anchorMax = Vector2.one;
					obj3.sizeDelta = Vector2.zero;
					obj3.anchoredPosition = Vector2.zero;
					Image val9 = val8.AddComponent<Image>();
					if ((Object)(object)_borderSprite != (Object)null)
					{
						val9.sprite = _borderSprite;
						val9.type = (Type)1;
					}
					((Graphic)val9).color = Color.white;
					((Graphic)val9).raycastTarget = false;
					GameObject val10 = new GameObject("Text");
					val10.transform.SetParent(val7.transform, false);
					RectTransform obj4 = val10.AddComponent<RectTransform>();
					obj4.anchorMin = Vector2.zero;
					obj4.anchorMax = Vector2.one;
					obj4.sizeDelta = Vector2.zero;
					obj4.anchoredPosition = Vector2.zero;
					TextMeshProUGUI val11 = val10.AddComponent<TextMeshProUGUI>();
					((TMP_Text)val11).text = text;
					((TMP_Text)val11).alignment = (TextAlignmentOptions)514;
					((Graphic)val11).color = Color.white;
					((TMP_Text)val11).enableAutoSizing = true;
					((TMP_Text)val11).fontSizeMin = 6f;
					((TMP_Text)val11).fontSizeMax = 42f;
					if ((Object)(object)val6 != (Object)null)
					{
						((TMP_Text)val11).font = val6;
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[BoneMenuScrollButtons] CreateNavButtons: " + ex.Message);
			}
		}

		private static void EnsureSprites()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_fillSprite != (Object)null)
			{
				return;
			}
			int num = 64;
			int num2 = 12;
			int num3 = 3;
			Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
			((Texture)val).filterMode = (FilterMode)1;
			Texture2D val2 = new Texture2D(num, num, (TextureFormat)4, false);
			((Texture)val2).filterMode = (FilterMode)1;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					float num4 = RoundedRectSDF(j, i, num, num, num2);
					bool flag = num4 <= 0f;
					bool flag2 = flag && num4 > (float)(-num3);
					val.SetPixel(j, i, flag ? Color.white : Color.clear);
					val2.SetPixel(j, i, flag2 ? Color.white : Color.clear);
				}
			}
			val.Apply();
			val2.Apply();
			float num5 = (float)num2 + 1f;
			Vector4 val3 = default(Vector4);
			((Vector4)(ref val3))..ctor(num5, num5, num5, num5);
			_fillSprite = Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val3);
			_borderSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val3);
		}

		private static float RoundedRectSDF(int px, int py, int w, int h, int r)
		{
			bool num = px < r || px > w - r - 1;
			bool flag = py < r || py > h - r - 1;
			if (num && flag)
			{
				float num2 = ((px < r) ? r : (w - r - 1));
				float num3 = ((py < r) ? r : (h - r - 1));
				float num4 = (float)px - num2;
				float num5 = (float)py - num3;
				return Mathf.Sqrt(num4 * num4 + num5 * num5) - (float)r;
			}
			float num6 = px;
			float num7 = w - 1 - px;
			float num8 = py;
			float num9 = h - 1 - py;
			return 0f - Mathf.Min(Mathf.Min(num6, num7), Mathf.Min(num8, num9));
		}
	}
	public static class BoneMenuScrollClamp
	{
		private static Page _ourPage;

		private static bool _hooked;

		private static bool _active;

		private static ScrollRect _scrollRect;

		private const float TargetVelocity = 1500f;

		public static void Register(Page page)
		{
			_ourPage = page;
			if (!_hooked)
			{
				Menu.OnPageOpened += OnPageOpened;
				_hooked = true;
			}
		}

		private static void OnPageOpened(Page page)
		{
			_active = page == _ourPage;
			if (_active && (Object)(object)_scrollRect == (Object)null)
			{
				CacheScrollRect();
			}
		}

		private static void CacheScrollRect()
		{
			try
			{
				GUIMenu instance = GUIMenu.Instance;
				if (!((Object)(object)instance == (Object)null))
				{
					Transform val = ((Component)instance).transform.Find("Page/Content/Viewport");
					if ((Object)(object)val != (Object)null)
					{
						_scrollRect = ((Component)val).GetComponent<ScrollRect>();
					}
				}
			}
			catch
			{
			}
		}

		public static void OnUpdate()
		{
			//IL_001b: 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)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!_active || (Object)(object)_scrollRect == (Object)null)
			{
				return;
			}
			try
			{
				Vector2 velocity = _scrollRect.velocity;
				if (Mathf.Abs(velocity.y) > 1f)
				{
					_scrollRect.velocity = new Vector2(velocity.x, Mathf.Sign(velocity.y) * 1500f);
				}
			}
			catch
			{
			}
		}
	}
	public static class LocalMirror
	{
		private struct HeldItemState
		{
			public int PlayerItemId;

			public GameObject CloneVisual;

			public GameObject PlayerSourceRoot;

			public ItemPersistentSync PersistentSync;
		}

		private struct SeatedItemState
		{
			public int PlayerSeatRootId;

			public GameObject CloneVisual;

			public GameObject PlayerSourceRoot;

			public ItemPersistentSync PersistentSync;
		}

		private class RemoteRigClone
		{
			public RigManager SourceRig;

			public int SourceRigId;

			public GameObject Visual;

			public Transform SourceAvatarT;

			public List<Transform> SrcBones = new List<Transform>();

			public List<Transform> DstBones = new List<Transform>();

			public List<(SkinnedMeshRenderer src, SkinnedMeshRenderer dst)> RendererPairs = new List<(SkinnedMeshRenderer, SkinnedMeshRenderer)>();

			public float LastProxTime;

			public float LastHeldTime;

			public Dictionary<int, HolsterVisual> HolsterVisuals;

			public Dictionary<string, GameObject> RemoteCosmetics;

			public HashSet<string> RemoteCosmeticsLoading;

			public int FrameCounter;

			public bool Functional;
		}

		private class HolsterVisual
		{
			public int HostId;

			public GameObject Visual;
		}

		private class ItemPersistentSync
		{
			public List<(Transform src, Transform dst)> Bones = new List<(Transform, Transform)>();

			public List<(SkinnedMeshRenderer src, SkinnedMeshRenderer dst)> SkinnedRenderers = new List<(SkinnedMeshRenderer, SkinnedMeshRenderer)>();

			public List<(MeshRenderer src, MeshRenderer dst)> MeshRenderers = new List<(MeshRenderer, MeshRenderer)>();
		}

		private static bool _enabled;

		private static bool _fusionLoadedChecked;

		private static bool _fusionLoadedCached;

		private static bool _firstEnableFixDone;

		private static GameObject _root;

		private static Transform _volumeTran;

		private static Transform _reflectTran;

		private static Transform _reflectionInitalTran;

		private static Transform _avatarsTran;

		private static Mirror _mirror;

		public static float Distance = 1.5f;

		public static bool ScaleByAvatarHeight = true;

		public static bool FollowHead = false;

		private static Vector3? _frozenFwd;

		public static bool StayInPlace = false;

		private const float BaseAvatarHeight = 1.75f;

		private static bool _waitingForClone;

		private static readonly List<Transform> _srcBones = new List<Transform>();

		private static readonly List<Transform> _dstBones = new List<Transform>();

		private static readonly HashSet<int> _skipPositionCopy = new HashSet<int>();

		private static readonly HashSet<int> _headRegionInstanceIds = new HashSet<int>();

		private static readonly List<(SkinnedMeshRenderer src, SkinnedMeshRenderer dst)> _rendererPairs = new List<(SkinnedMeshRenderer, SkinnedMeshRenderer)>();

		private static bool _localAvatarFunctional;

		private static int _localStateSyncFrameCounter;

		private const int LocalStateSyncPeriod = 6;

		private static readonly Dictionary<int, GameObject> _cosmeticMirrorCopies = new Dictionary<int, GameObject>();

		private static HeldItemState _leftHeldState;

		private static HeldItemState _rightHeldState;

		private static SeatedItemState _seatedState;

		private static readonly Dictionary<int, GameObject> _proximityVisuals = new Dictionary<int, GameObject>();

		private static readonly Dictionary<int, ItemPersistentSync> _proximityPersistentSync = new Dictionary<int, ItemPersistentSync>();

		private static readonly Dictionary<int, GameObject> _proximitySourceRoots = new Dictionary<int, GameObject>();

		private static readonly HashSet<int> _claimedRootIds = new HashSet<int>();

		private const int RemoteRigSlowSyncPeriod = 6;

		private static readonly Dictionary<int, HolsterVisual> _localHolsterVisuals = new Dictionary<int, HolsterVisual>();

		private static readonly Dictionary<int, RemoteRigClone> _remoteRigClones = new Dictionary<int, RemoteRigClone>();

		private static float _remoteEligibilityNextTime;

		private const float EligibilityScanPeriod = 0.1f;

		private static bool _remoteScanForcedOnce;

		private const float ProximityGrace = 0.5f;

		private const float HeldGrace = 0.25f;

		private static int _remoteCloneLastWarnFrame = -1;

		private static GameObject _proximityCircleGo;

		private static LineRenderer _proximityCircleLine;

		private const int ProximityCircleSegments = 64;

		private static Transform _playerLeftHandTransform;

		private static Transform _playerRightHandTransform;

		private static Transform _cloneLeftHandTransform;

		private static Transform _cloneRightHandTransform;

		private static FieldInfo _fAccessoryInstances;

		private static bool _accessoryInstancesResolveAttempted;

		private static FieldInfo _fCosmeticSpawnableCrateRef;

		private static bool _cosmeticSpawnableCrateRefResolved;

		private static bool _poseCopyActive;

		private static int _pendingRebuildFrames;

		private const int RebuildDelayFrames = 6;

		private static FieldInfo _fReflectTran;

		private static FieldInfo _fReflectionInital;

		private static FieldInfo _fRigManager;

		private static FieldInfo _fAvatarsTran;

		private static FieldInfo _fCachedReflections;

		private static PropertyInfo _pReflectTran;

		private static PropertyInfo _pReflectionInital;

		private static PropertyInfo _pRigManager;

		private static PropertyInfo _pAvatarsTran;

		private static PropertyInfo _pCachedReflections;

		private static MethodInfo _mSwapNoArg;

		private static bool _accessorsResolved;

		private static int _lastPreCullFrame = -1;

		private static bool _preCullHooked;

		private static Action<Camera> _preCullDelegate;

		private static bool _gripHooksInstalled;

		private static Action<Grip, Hand> _gripAttachedDelegate;

		private static Action<Grip, Hand> _gripDetachedDelegate;

		private static readonly HashSet<string> _functionalDriverComponentNames = new HashSet<string> { "UltEventHolder", "DelayedUltEventHolder", "LifeCycleEvents", "UpdateEvents", "ZoneEvents" };

		private static FieldInfo[] _cachedGripEventFields;

		private static readonly HashSet<string> _mirrorBlacklistBarcodes = new HashSet<string> { "Lakatrazz.FusionContent.Spawnable.FusionMenu", "InnocentCitizen.Helldivers2StratagemBall.Spawnable.Helldivers2StratagemBall1" };

		public static bool Enabled => _enabled;

		public static event Action<bool> OnEnabledChanged;

		private static bool IsFusionLoaded()
		{
			if (_fusionLoadedChecked)
			{
				return _fusionLoadedCached;
			}
			_fusionLoadedChecked = true;
			try
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					if (assemblies[i].GetName().Name == "LabFusion")
					{
						_fusionLoadedCached = true;
						break;
					}
				}
			}
			catch
			{
			}
			return _fusionLoadedCached;
		}

		private static void RemoteWarn(string msg)
		{
			int num = -1;
			try
			{
				num = Time.frameCount;
			}
			catch
			{
			}
			if (num == _remoteCloneLastWarnFrame)
			{
				return;
			}
			_remoteCloneLastWarnFrame = num;
			try
			{
				MelonLogger.Warning("[LocalMirror.IncludeOthers] " + msg);
			}
			catch
			{
			}
		}

		public static void Enable()
		{
			if (_enabled)
			{
				return;
			}
			try
			{
				BuildRig();
				_enabled = true;
				HookPreCull();
				HookGripEvents();
				try
				{
					LocalMirror.OnEnabledChanged?.Invoke(obj: true);
				}
				catch
				{
				}
				if (!_firstEnableFixDone)
				{
					_firstEnableFixDone = true;
					try
					{
						MelonCoroutines.Start(FirstEnableShake());
						return;
					}
					catch (Exception ex)
					{
						MelonLogger.Warning("[LocalMirror] FirstEnableShake start threw: " + ex.Message);
						return;
					}
				}
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("[LocalMirror] enable threw: " + ex2.Message);
				Cleanup();
			}
		}

		private static IEnumerator FirstEnableShake()
		{
			int waited = 0;
			while ((!_enabled || !_poseCopyActive) && waited++ < 600)
			{
				yield return null;
			}
			if (!_enabled)
			{
				yield break;
			}
			if (waited >= 600)
			{
				MelonLogger.Warning("[LocalMirror] FirstEnableShake: step1 timed out waiting for initial settle");
				yield break;
			}
			Disable();
			waited = 0;
			while ((_enabled || _poseCopyActive) && waited++ < 600)
			{
				yield return null;
			}
			if (waited >= 600)
			{
				MelonLogger.Warning("[LocalMirror] FirstEnableShake: step2 timed out waiting for disable settle");
				yield break;
			}
			Enable();
			waited = 0;
			while ((!_enabled || !_poseCopyActive) && waited++ < 600)
			{
				yield return null;
			}
			if (waited >= 600)
			{
				MelonLogger.Warning("[LocalMirror] FirstEnableShake: step3 timed out waiting for second enable settle");
			}
		}

		public static void Disable()
		{
			if (!_enabled)
			{
				return;
			}
			_enabled = false;
			UnhookPreCull();
			UnhookGripEvents();
			Cleanup();
			try
			{
				LocalMirror.OnEnabledChanged?.Invoke(obj: false);
			}
			catch
			{
			}
		}

		private static void HookPreCull()
		{
			if (_preCullHooked)
			{
				return;
			}
			try
			{
				_preCullDelegate = OnAnyCameraPreCull;
				Camera.onPreCull += CameraCallback.op_Implicit(_preCullDelegate);
				_preCullHooked = true;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] HookPreCull threw: " + ex.Message);
			}
		}

		private static void UnhookPreCull()
		{
			if (!_preCullHooked)
			{
				return;
			}
			try
			{
				if (_preCullDelegate != null)
				{
					Camera.onPreCull -= CameraCallback.op_Implicit(_preCullDelegate);
				}
			}
			catch
			{
			}
			_preCullDelegate = null;
			_preCullHooked = false;
			_lastPreCullFrame = -1;
		}

		private static void OnAnyCameraPreCull(Camera _)
		{
			if (!_enabled || !_poseCopyActive)
			{
				return;
			}
			int frameCount = Time.frameCount;
			if (frameCount == _lastPreCullFrame)
			{
				return;
			}
			_lastPreCullFrame = frameCount;
			try
			{
				CopyPose();
			}
			catch
			{
			}
		}

		private static void HookGripEvents()
		{
			if (_gripHooksInstalled)
			{
				return;
			}
			try
			{
				_gripAttachedDelegate = OnGripAttachedRemote;
				_gripDetachedDelegate = OnGripDetachedRemote;
				Hooking.OnGripAttached += _gripAttachedDelegate;
				Hooking.OnGripDetached += _gripDetachedDelegate;
				_gripHooksInstalled = true;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] HookGripEvents threw: " + ex.Message);
			}
		}

		private static void UnhookGripEvents()
		{
			if (!_gripHooksInstalled)
			{
				return;
			}
			try
			{
				if (_gripAttachedDelegate != null)
				{
					Hooking.OnGripAttached -= _gripAttachedDelegate;
				}
				if (_gripDetachedDelegate != null)
				{
					Hooking.OnGripDetached -= _gripDetachedDelegate;
				}
			}
			catch
			{
			}
			_gripAttachedDelegate = null;
			_gripDetachedDelegate = null;
			_gripHooksInstalled = false;
		}

		private static void OnGripAttachedRemote(Grip grip, Hand hand)
		{
			//IL_00c3: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)grip == (Object)null || (Object)(object)hand == (Object)null)
			{
				return;
			}
			try
			{
				if (!Config.LocalMirrorIncludeOthersEnabled.Value || !Config.LocalMirrorHeldItemAwarenessEnabled.Value)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.physicsRig == (Object)null)
			{
				return;
			}
			int num = 0;
			try
			{
				num = ((Object)(Component)hand).GetInstanceID();
			}
			catch
			{
				return;
			}
			int num2 = 0;
			int num3 = 0;
			try
			{
				if ((Object)(object)rigManager.physicsRig.leftHand != (Object)null)
				{
					num2 = ((Object)(Component)rigManager.physicsRig.leftHand).GetInstanceID();
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)rigManager.physicsRig.rightHand != (Object)null)
				{
					num3 = ((Object)(Component)rigManager.physicsRig.rightHand).GetInstanceID();
				}
			}
			catch
			{
			}
			if (num != num2 && num != num3)
			{
				return;
			}
			Transform val = null;
			try
			{
				val = ((Component)grip).transform;
			}
			catch
			{
				return;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			RigManager val2 = null;
			try
			{
				val2 = ((Component)val).GetComponentInParent<RigManager>();
			}
			catch
			{
				return;
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				int instanceID = ((Object)((Component)rigManager).gameObject).GetInstanceID();
				if (((Object)((Component)val2).gameObject).GetInstanceID() != instanceID)
				{
					_remoteEligibilityNextTime = 0f;
					_remoteScanForcedOnce = true;
				}
			}
		}

		private static void OnGripDetachedRemote(Grip grip, Hand hand)
		{
			//IL_00a0: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)grip == (Object)null || (Object)(object)hand == (Object)null)
				{
					return;
				}
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.physicsRig == (Object)null)
				{
					return;
				}
				int num = 0;
				try
				{
					num = ((Object)(Component)hand).GetInstanceID();
				}
				catch
				{
					return;
				}
				int num2 = 0;
				int num3 = 0;
				try
				{
					if ((Object)(object)rigManager.physicsRig.leftHand != (Object)null)
					{
						num2 = ((Object)(Component)rigManager.physicsRig.leftHand).GetInstanceID();
					}
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)rigManager.physicsRig.rightHand != (Object)null)
					{
						num3 = ((Object)(Component)rigManager.physicsRig.rightHand).GetInstanceID();
					}
				}
				catch
				{
				}
				if (num != num2 && num != num3)
				{
					return;
				}
				Transform val = null;
				try
				{
					val = ((Component)grip).transform;
				}
				catch
				{
				}
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				RigManager val2 = null;
				try
				{
					val2 = ((Component)val).GetComponentInParent<RigManager>();
				}
				catch
				{
				}
				if (!((Object)(object)val2 == (Object)null))
				{
					int instanceID = ((Object)((Component)val2).gameObject).GetInstanceID();
					if (instanceID != ((Object)((Component)rigManager).gameObject).GetInstanceID() && _remoteRigClones.TryGetValue(instanceID, out var value) && value != null)
					{
						value.LastHeldTime = -1E+09f;
						_remoteEligibilityNextTime = 0f;
						_remoteScanForcedOnce = true;
					}
				}
			}
			catch
			{
			}
		}

		public static void Toggle()
		{
			if (_enabled)
			{
				Disable();
			}
			else
			{
				Enable();
			}
		}

		public static void OnLevelLoaded()
		{
			if (_enabled)
			{
				Disable();
				Enable();
			}
			_pendingRebuildFrames = 0;
			_firstEnableFixDone = false;
		}

		public static void OnAvatarChanged(Avatar avatar)
		{
			if (!_enabled || (Object)(object)avatar == (Object)null)
			{
				return;
			}
			try
			{
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager == (Object)null)
				{
					return;
				}
				RigManager componentInParent = ((Component)avatar).GetComponentInParent<RigManager>();
				if ((Object)(object)componentInParent == (Object)null || ((Object)componentInParent).GetInstanceID() != ((Object)rigManager).GetInstanceID())
				{
					return;
				}
			}
			catch
			{
				return;
			}
			_pendingRebuildFrames = 6;
		}

		public static void LateEnforce()
		{
			if (!_enabled || !_poseCopyActive)
			{
				return;
			}
			try
			{
				CopyPose();
			}
			catch
			{
			}
		}

		public static void OnUpdate()
		{
			if (!_enabled)
			{
				return;
			}
			if (_pendingRebuildFrames > 0)
			{
				_pendingRebuildFrames--;
				if (_pendingRebuildFrames == 0)
				{
					try
					{
						RigManager rigManager = Player.RigManager;
						if ((Object)(object)rigManager != (Object)null && (Object)(object)rigManager.avatar != (Object)null && (Object)(object)((Component)rigManager.avatar).transform != (Object)null)
						{
							Disable();
							Enable();
							return;
						}
						_pendingRebuildFrames = 2;
					}
					catch (Exception ex)
					{
						MelonLogger.Warning("[LocalMirror] avatar-swap rebuild threw: " + ex.Message);
					}
				}
			}
			if ((Object)(object)_root == (Object)null)
			{
				Disable();
				return;
			}
			try
			{
				FollowPlayer();
			}
			catch
			{
			}
			if (_waitingForClone && HasActiveClone())
			{
				_waitingForClone = false;
				TakeOverPoseCopy();
			}
			if (!_poseCopyActive)
			{
				return;
			}
			try
			{
				CopyPose();
			}
			catch
			{
			}
		}

		private static bool HasActiveClone()
		{
			if ((Object)(object)_avatarsTran == (Object)null)
			{
				return false;
			}
			try
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void TakeOverPoseCopy()
		{
			//IL_00d7: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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)
			try
			{
				Object.Destroy((Object)(object)_mirror);
			}
			catch
			{
			}
			_mirror = null;
			_srcBones.Clear();
			_dstBones.Clear();
			_skipPositionCopy.Clear();
			_headRegionInstanceIds.Clear();
			try
			{
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
				{
					MelonLogger.Warning("[LocalMirror] take-over skipped: no player avatar.");
					return;
				}
				Transform val = null;
				if ((Object)(object)_avatarsTran != (Object)null)
				{
					for (int i = 0; i < _avatarsTran.childCount; i++)
					{
						Transform child = _avatarsTran.GetChild(i);
						if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
						{
							val = child;
							break;
						}
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					MelonLogger.Warning("[LocalMirror] take-over skipped: no active clone under AVATARS.");
					return;
				}
				try
				{
					Vector3 localScale = ((Component)rigManager.avatar).transform.localScale;
					val.localScale = new Vector3(0f - localScale.x, localScale.y, localScale.z);
				}
				catch (Exception ex)
				{
					MelonLogger.Warning("[LocalMirror] could not set clone scale: " + ex.Message);
				}
				try
				{
					Avatar component = ((Component)val).GetComponent<Avatar>();
					if ((Object)(object)component != (Object)null)
					{
						component.eyeOffset = 0f;
					}
				}
				catch (Exception ex2)
				{
					MelonLogger.Warning("[LocalMirror] eyeOffset reset threw: " + ex2.Message);
				}
				try
				{
					BuildRendererPairs(((Component)rigManager.avatar).transform, val);
					SyncRendererStates();
				}
				catch (Exception ex3)
				{
					MelonLogger.Warning("[LocalMirror] renderer pair build threw: " + ex3.Message);
				}
				try
				{
					DisableCloneGrips(val);
				}
				catch (Exception ex4)
				{
					MelonLogger.Warning("[LocalMirror] DisableCloneGrips threw: " + ex4.Message);
				}
				try
				{
					_localAvatarFunctional = IsAvatarFunctional(((Component)rigManager.avatar).transform);
					_localStateSyncFrameCounter = 0;
				}
				catch (Exception ex5)
				{
					MelonLogger.Warning("[LocalMirror] IsAvatarFunctional threw: " + ex5.Message + " — defaulting to functional");
					_localAvatarFunctional = true;
				}
				ResolveHumanoidHeadInstanceIds(val);
				ResolveHumanoidHandTransforms(((Component)rigManager.avatar).transform, val);
				BuildBoneMap(((Component)rigManager.avatar).transform, val);
				_poseCopyActive = true;
			}
			catch (Exception ex6)
			{
				MelonLogger.Warning("[LocalMirror] TakeOverPoseCopy threw: " + ex6.Message);
			}
		}

		private static void BuildBoneMap(Transform src, Transform dst)
		{
			if ((Object)(object)src == (Object)null || (Object)(object)dst == (Object)null)
			{
				return;
			}
			int childCount = src.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = src.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					Transform val = dst.Find(((Object)child).name);
					if (!((Object)(object)val == (Object)null))
					{
						BuildBoneMapInternal(child, val);
					}
				}
			}
		}

		private static void BuildBoneMapInternal(Transform src, Transform dst)
		{
			if ((Object)(object)src == (Object)null || (Object)(object)dst == (Object)null)
			{
				return;
			}
			int count = _srcBones.Count;
			_srcBones.Add(src);
			_dstBones.Add(dst);
			try
			{
				if (_headRegionInstanceIds.Contains(((Object)dst).GetInstanceID()))
				{
					_skipPositionCopy.Add(count);
				}
			}
			catch
			{
			}
			int childCount = src.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = src.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					Transform val = dst.Find(((Object)child).name);
					if (!((Object)(object)val == (Object)null))
					{
						BuildBoneMapInternal(child, val);
					}
				}
			}
		}

		private static void ResolveHumanoidHeadInstanceIds(Transform cloneRoot)
		{
			if ((Object)(object)cloneRoot == (Object)null)
			{
				return;
			}
			try
			{
				Animator val = ((Component)cloneRoot).GetComponent<Animator>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)cloneRoot).GetComponentInChildren<Animator>(true);
				}
				if (!((Object)(object)val == (Object)null))
				{
					bool flag = false;
					try
					{
						flag = val.isHuman;
					}
					catch
					{
					}
					if (flag)
					{
						AddHumanoidBone(val, (HumanBodyBones)10);
						AddHumanoidBone(val, (HumanBodyBones)9);
						AddHumanoidBone(val, (HumanBodyBones)23);
						AddHumanoidBone(val, (HumanBodyBones)21);
						AddHumanoidBone(val, (HumanBodyBones)22);
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] ResolveHumanoidHeadInstanceIds threw: " + ex.Message);
			}
		}

		private static void AddHumanoidBone(Animator animator, HumanBodyBones bone)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform boneTransform = animator.GetBoneTransform(bone);
				if ((Object)(object)boneTransform != (Object)null)
				{
					_headRegionInstanceIds.Add(((Object)boneTransform).GetInstanceID());
				}
			}
			catch
			{
			}
		}

		private static void ResolveHumanoidHandTransforms(Transform playerAvatarT, Transform cloneAvatarT)
		{
			_playerLeftHandTransform = null;
			_playerRightHandTransform = null;
			_cloneLeftHandTransform = null;
			_cloneRightHandTransform = null;
			try
			{
				Animator val = ((playerAvatarT != null) ? ((Component)playerAvatarT).GetComponent<Animator>() : null);
				if ((Object)(object)val == (Object)null)
				{
					val = ((playerAvatarT != null) ? ((Component)playerAvatarT).GetComponentInChildren<Animator>(true) : null);
				}
				if ((Object)(object)val != (Object)null && val.isHuman)
				{
					try
					{
						_playerLeftHandTransform = val.GetBoneTransform((HumanBodyBones)17);
					}
					catch
					{
					}
					try
					{
						_playerRightHandTransform = val.GetBoneTransform((HumanBodyBones)18);
					}
					catch
					{
					}
				}
				Animator val2 = ((cloneAvatarT != null) ? ((Component)cloneAvatarT).GetComponent<Animator>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((cloneAvatarT != null) ? ((Component)cloneAvatarT).GetComponentInChildren<Animator>(true) : null);
				}
				if ((Object)(object)val2 != (Object)null && val2.isHuman)
				{
					try
					{
						_cloneLeftHandTransform = val2.GetBoneTransform((HumanBodyBones)17);
					}
					catch
					{
					}
					try
					{
						_cloneRightHandTransform = val2.GetBoneTransform((HumanBodyBones)18);
						return;
					}
					catch
					{
						return;
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] ResolveHumanoidHandTransforms threw: " + ex.Message);
			}
		}

		private static void BuildRendererPairs(Transform playerRoot, Transform cloneRoot)
		{
			_rendererPairs.Clear();
			if ((Object)(object)playerRoot == (Object)null || (Object)(object)cloneRoot == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren = ((Component)playerRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren2 = ((Component)cloneRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			if (componentsInChildren == null || componentsInChildren2 == null)
			{
				return;
			}
			Dictionary<string, SkinnedMeshRenderer> dictionary = new Dictionary<string, SkinnedMeshRenderer>();
			for (int i = 0; i < componentsInChildren.Count; i++)
			{
				SkinnedMeshRenderer val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null))
				{
					string text = null;
					try
					{
						text = ((Object)((Component)val).gameObject).name;
					}
					catch
					{
					}
					if (!string.IsNullOrEmpty(text) && !dictionary.ContainsKey(text))
					{
						dictionary[text] = val;
					}
				}
			}
			for (int j = 0; j < componentsInChildren2.Count; j++)
			{
				SkinnedMeshRenderer val2 = componentsInChildren2[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					string text2 = null;
					try
					{
						text2 = ((Object)((Component)val2).gameObject).name;
					}
					catch
					{
					}
					if (!string.IsNullOrEmpty(text2) && dictionary.TryGetValue(text2, out var value) && !((Object)(object)value == (Object)null))
					{
						_rendererPairs.Add((value, val2));
					}
				}
			}
		}

		private static void SyncRendererStates()
		{
			bool flag = _localAvatarFunctional && _localStateSyncFrameCounter % 6 == 0;
			int count = _rendererPairs.Count;
			for (int i = 0; i < count; i++)
			{
				var (val, val2) = _rendererPairs[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					continue;
				}
				bool flag2 = true;
				try
				{
					flag2 = ((Renderer)val).enabled;
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val2).enabled != flag2)
					{
						((Renderer)val2).enabled = flag2;
					}
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val2).forceRenderingOff)
					{
						((Renderer)val2).forceRenderingOff = false;
					}
				}
				catch
				{
				}
				if (!flag)
				{
					continue;
				}
				try
				{
					Mesh sharedMesh = val.sharedMesh;
					if (!((Object)(object)sharedMesh != (Object)null) || !((Object)(object)val2.sharedMesh != (Object)null))
					{
						continue;
					}
					int blendShapeCount = sharedMesh.blendShapeCount;
					for (int j = 0; j < blendShapeCount; j++)
					{
						float blendShapeWeight;
						try
						{
							blendShapeWeight = val.GetBlendShapeWeight(j);
						}
						catch
						{
							continue;
						}
						float blendShapeWeight2;
						try
						{
							blendShapeWeight2 = val2.GetBlendShapeWeight(j);
						}
						catch
						{
							continue;
						}
						if (Mathf.Abs(blendShapeWeight2 - blendShapeWeight) > 0.001f)
						{
							try
							{
								val2.SetBlendShapeWeight(j, blendShapeWeight);
							}
							catch
							{
							}
						}
					}
				}
				catch
				{
				}
			}
		}

		private static void DisableCloneGrips(Transform cloneRoot)
		{
			if ((Object)(object)cloneRoot == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Grip> componentsInChildren = ((Component)cloneRoot).GetComponentsInChildren<Grip>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			for (int i = 0; i < componentsInChildren.Count; i++)
			{
				Grip val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null))
				{
					try
					{
						((Behaviour)val).enabled = false;
					}
					catch
					{
					}
				}
			}
		}

		private static bool IsAvatarFunctional(Transform avatarRoot)
		{
			if ((Object)(object)avatarRoot == (Object)null)
			{
				return false;
			}
			try
			{
				Il2CppArrayBase<Grip> componentsInChildren = ((Component)avatarRoot).GetComponentsInChildren<Grip>(true);
				if (componentsInChildren != null)
				{
					int count = componentsInChildren.Count;
					for (int i = 0; i < count; i++)
					{
						Grip val = componentsInChildren[i];
						if (!((Object)(object)val == (Object)null) && GripHasWiredEvents(val))
						{
							return true;
						}
					}
				}
				Il2CppArrayBase<Component> componentsInChildren2 = ((Component)avatarRoot).GetComponentsInChildren<Component>(true);
				if (componentsInChildren2 != null)
				{
					int count2 = componentsInChildren2.Count;
					for (int j = 0; j < count2; j++)
					{
						Component val2 = componentsInChildren2[j];
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						string text = null;
						try
						{
							text = ((MemberInfo)((Object)val2).GetIl2CppType()).Name;
						}
						catch
						{
						}
						if (text == null)
						{
							try
							{
								text = ((object)val2).GetType().Name;
							}
							catch
							{
							}
						}
						if (text != null && _functionalDriverComponentNames.Contains(text))
						{
							return true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror.Functional] IsAvatarFunctional threw: " + ex.Message);
			}
			return false;
		}

		private static bool GripHasWiredEvents(Grip g)
		{
			if ((Object)(object)g == (Object)null)
			{
				return false;
			}
			try
			{
				if (_cachedGripEventFields == null)
				{
					FieldInfo[] fields = typeof(Grip).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					List<FieldInfo> list = new List<FieldInfo>();
					if (fields != null)
					{
						foreach (FieldInfo fieldInfo in fields)
						{
							if (!(fieldInfo == null) && typeof(UnityEventBase).IsAssignableFrom(fieldInfo.FieldType))
							{
								list.Add(fieldInfo);
							}
						}
					}
					_cachedGripEventFields = list.ToArray();
				}
				int num = _cachedGripEventFields.Length;
				for (int j = 0; j < num; j++)
				{
					FieldInfo fieldInfo2 = _cachedGripEventFields[j];
					object obj = null;
					try
					{
						obj = fieldInfo2.GetValue(g);
					}
					catch
					{
						continue;
					}
					UnityEventBase val = (UnityEventBase)((obj is UnityEventBase) ? obj : null);
					if (val != null)
					{
						int num2 = 0;
						try
						{
							num2 = val.GetPersistentEventCount();
						}
						catch
						{
						}
						if (num2 > 0)
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void SyncProximityMirror()
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorProximityAwarenessEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if (_proximityVisuals.Count > 0)
				{
					ClearProximityVisuals();
				}
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)rigManager.avatar).transform;
			Transform val = null;
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						val = child;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float num = 5f;
			try
			{
				num = Config.LocalMirrorProximityRadius.Value;
			}
			catch
			{
			}
			if (num <= 0.0001f)
			{
				if (_proximityVisuals.Count > 0)
				{
					ClearProximityVisuals();
				}
				return;
			}
			Vector3 val2;
			try
			{
				Transform transform2 = ((Component)((Rig)rigManager.physicsRig).m_chest).transform;
				val2 = (((Object)(object)transform2 != (Object)null) ? transform2.position : transform.position);
			}
			catch
			{
				val2 = transform.position;
			}
			int instanceID = ((Object)((Component)rigManager).gameObject).GetInstanceID();
			Il2CppReferenceArray<Collider> val3 = Physics.OverlapSphere(val2, num);
			HashSet<int> hashSet = new HashSet<int>();
			if (val3 != null)
			{
				int length = ((Il2CppArrayBase<Collider>)(object)val3).Length;
				for (int j = 0; j < length; j++)
				{
					Collider val4 = ((Il2CppArrayBase<Collider>)(object)val3)[j];
					if ((Object)(object)val4 == (Object)null)
					{
						continue;
					}
					GameObject gameObject = ((Component)val4).gameObject;
					if ((Object)(object)gameObject == (Object)null)
					{
						continue;
					}
					Poolee val5 = null;
					try
					{
						val5 = gameObject.GetComponentInParent<Poolee>();
					}
					catch
					{
					}
					if ((Object)(object)val5 == (Object)null)
					{
						continue;
					}
					GameObject val6 = null;
					try
					{
						val6 = ((Component)val5).gameObject;
					}
					catch
					{
					}
					if (!((Object)(object)val6 == (Object)null) && ShouldMirrorPoolee(val5, val6, instanceID))
					{
						int instanceID2 = ((Object)val6).GetInstanceID();
						if (hashSet.Add(instanceID2))
						{
							UpdateProximityVisual(val6, instanceID2, transform, val);
							_claimedRootIds.Add(instanceID2);
						}
					}
				}
			}
			try
			{
				if ((Object)(object)rigManager.physicsRig != (Object)null)
				{
					IncludeHandHeldInProximity(rigManager.physicsRig.leftHand, val2, num, instanceID, hashSet, transform, val);
					IncludeHandHeldInProximity(rigManager.physicsRig.rightHand, val2, num, instanceID, hashSet, transform, val);
				}
				Seat val7 = null;
				try
				{
					val7 = rigManager.activeSeat;
				}
				catch
				{
				}
				if ((Object)(object)val7 != (Object)null)
				{
					GameObject val8 = null;
					try
					{
						val8 = ((Component)val7).gameObject;
					}
					catch
					{
					}
					if ((Object)(object)val8 != (Object)null)
					{
						Poolee poolee = null;
						try
						{
							poolee = val8.GetComponentInParent<Poolee>();
						}
						catch
						{
						}
						IncludePooleeInProximity(poolee, val2, num, instanceID, hashSet, transform, val);
					}
				}
			}
			catch
			{
			}
			List<int> list = null;
			foreach (KeyValuePair<int, GameObject> proximityVisual in _proximityVisuals)
			{
				if (!hashSet.Contains(proximityVisual.Key))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(proximityVisual.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			for (int k = 0; k < list.Count; k++)
			{
				int key = list[k];
				if (_proximityVisuals.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value);
					}
					catch
					{
					}
				}
				_proximityVisuals.Remove(key);
				_proximityPersistentSync.Remove(key);
				_proximitySourceRoots.Remove(key);
			}
		}

		private static void UpdateProximityVisual(GameObject src, int rootId, Transform playerAvatarT, Transform cloneAvatarT)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_0067: 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)
			//IL_0077: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (!_proximityVisuals.TryGetValue(rootId, out var value) || (Object)(object)value == (Object)null)
			{
				value = BuildHeldVisual(src);
				if ((Object)(object)value == (Object)null)
				{
					return;
				}
				_proximityVisuals[rootId] = value;
				_proximitySourceRoots[rootId] = src;
				_proximityPersistentSync[rootId] = null;
			}
			Transform transform = src.transform;
			Vector3 localPosition = playerAvatarT.InverseTransformPoint(transform.position);
			Quaternion localRotation = Quaternion.Inverse(playerAvatarT.rotation) * transform.rotation;
			Transform transform2 = value.transform;
			if ((Object)(object)transform2.parent != (Object)(object)cloneAvatarT)
			{
				try
				{
					transform2.SetParent(cloneAvatarT, false);
				}
				catch
				{
				}
			}
			transform2.localPosition = localPosition;
			transform2.localRotation = localRotation;
			Vector3 lossyScale = transform.lossyScale;
			Vector3 lossyScale2 = cloneAvatarT.lossyScale;
			float num = Mathf.Abs(lossyScale2.x);
			if (num < 0.0001f)
			{
				num = 1f;
			}
			float num2 = Mathf.Abs(lossyScale2.y);
			if (num2 < 0.0001f)
			{
				num2 = 1f;
			}
			float num3 = Mathf.Abs(lossyScale2.z);
			if (num3 < 0.0001f)
			{
				num3 = 1f;
			}
			transform2.localScale = new Vector3(lossyScale.x / num, lossyScale.y / num2, lossyScale.z / num3);
			if (!value.activeSelf)
			{
				value.SetActive(true);
			}
			ItemPersistentSync value2 = null;
			_proximityPersistentSync.TryGetValue(rootId, out value2);
			ApplyPersistentItemUpdate(src, value, ref value2);
			_proximityPersistentSync[rootId] = value2;
		}

		private static void IncludeHandHeldInProximity(Hand hand, Vector3 origin, float radius, int localRigId, HashSet<int> seen, Transform playerAvatarT, Transform cloneAvatarT)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hand == (Object)null)
			{
				return;
			}
			GameObject val = null;
			try
			{
				val = hand.m_CurrentAttachedGO;
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null))
			{
				Poolee poolee = null;
				try
				{
					poolee = val.GetComponentInParent<Poolee>();
				}
				catch
				{
				}
				IncludePooleeInProximity(poolee, origin, radius, localRigId, seen, playerAvatarT, cloneAvatarT);
			}
		}

		private static void IncludePooleeInProximity(Poolee poolee, Vector3 origin, float radius, int localRigId, HashSet<int> seen, Transform playerAvatarT, Transform cloneAvatarT)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)poolee == (Object)null)
			{
				return;
			}
			GameObject val = null;
			try
			{
				val = ((Component)poolee).gameObject;
			}
			catch
			{
			}
			if (!((Object)(object)val == (Object)null) && ShouldMirrorPoolee(poolee, val, localRigId))
			{
				int instanceID = ((Object)val).GetInstanceID();
				float num = val.transform.position.x - origin.x;
				float num2 = val.transform.position.y - origin.y;
				float num3 = val.transform.position.z - origin.z;
				if (!(num * num + num2 * num2 + num3 * num3 > radius * radius) && seen.Add(instanceID))
				{
					UpdateProximityVisual(val, instanceID, playerAvatarT, cloneAvatarT);
					_claimedRootIds.Add(instanceID);
				}
			}
		}

		private static void ClearProximityVisuals()
		{
			foreach (KeyValuePair<int, GameObject> proximityVisual in _proximityVisuals)
			{
				if ((Object)(object)proximityVisual.Value != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)proximityVisual.Value);
					}
					catch
					{
					}
				}
			}
			_proximityVisuals.Clear();
			_proximityPersistentSync.Clear();
			_proximitySourceRoots.Clear();
		}

		private static void SyncProximityVisual()
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			bool flag2 = false;
			try
			{
				flag = Config.LocalMirrorProximityAwarenessEnabled.Value;
			}
			catch
			{
			}
			try
			{
				flag2 = Config.LocalMirrorProximityVisualEnabled.Value;
			}
			catch
			{
			}
			if (!flag || !flag2)
			{
				if ((Object)(object)_proximityCircleGo != (Object)null && _proximityCircleGo.activeSelf)
				{
					_proximityCircleGo.SetActive(false);
				}
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.physicsRig == (Object)null)
			{
				return;
			}
			Transform val = null;
			try
			{
				val = ((Component)((Rig)rigManager.physicsRig).m_chest).transform;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				try
				{
					Avatar avatar = rigManager.avatar;
					val = ((avatar != null) ? ((Component)avatar).transform : null);
				}
				catch
				{
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float num = 5f;
			try
			{
				num = Config.LocalMirrorProximityRadius.Value;
			}
			catch
			{
			}
			EnsureProximityCircle();
			if (!((Object)(object)_proximityCircleGo == (Object)null) && !((Object)(object)_proximityCircleLine == (Object)null))
			{
				if (!_proximityCircleGo.activeSelf)
				{
					_proximityCircleGo.SetActive(true);
				}
				Vector3 position = val.position;
				float num2 = 0.02f;
				_proximityCircleLine.startWidth = num2;
				_proximityCircleLine.endWidth = num2;
				for (int i = 0; i < 64; i++)
				{
					float num3 = (float)i / 64f * (float)Math.PI * 2f;
					_proximityCircleLine.SetPosition(i, new Vector3(position.x + Mathf.Cos(num3) * num, position.y, position.z + Mathf.Sin(num3) * num));
				}
			}
		}

		private static void EnsureProximityCircle()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_proximityCircleGo != (Object)null && (Object)(object)_proximityCircleGo != (Object)null)
			{
				return;
			}
			try
			{
				_proximityCircleGo = new GameObject("LocalMirror_ProximityCircle");
				Object.DontDestroyOnLoad((Object)(object)_proximityCircleGo);
				_proximityCircleLine = _proximityCircleGo.AddComponent<LineRenderer>();
				_proximityCircleLine.useWorldSpace = true;
				_proximityCircleLine.loop = true;
				_proximityCircleLine.positionCount = 64;
				((Renderer)_proximityCircleLine).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)_proximityCircleLine).receiveShadows = false;
				Shader val = Shader.Find("Sprites/Default");
				if ((Object)(object)val != (Object)null)
				{
					Material val2 = new Material(val);
					val2.color = Color.white;
					((Renderer)_proximityCircleLine).material = val2;
					_proximityCircleLine.startColor = Color.white;
					_proximityCircleLine.endColor = Color.white;
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] EnsureProximityCircle threw: " + ex.Message);
			}
		}

		private static void DestroyProximityCircle()
		{
			if ((Object)(object)_proximityCircleGo != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)_proximityCircleGo);
				}
				catch
				{
				}
				_proximityCircleGo = null;
				_proximityCircleLine = null;
			}
		}

		private static void SyncHeldItemMirror()
		{
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorHeldItemAwarenessEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if ((Object)(object)_leftHeldState.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref _leftHeldState);
				}
				if ((Object)(object)_rightHeldState.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref _rightHeldState);
				}
			}
			else
			{
				RigManager rigManager = Player.RigManager;
				if (!((Object)(object)rigManager == (Object)null) && !((Object)(object)rigManager.physicsRig == (Object)null))
				{
					UpdateHeldHand(rigManager.physicsRig.leftHand, _playerLeftHandTransform, _cloneLeftHandTransform, ref _leftHeldState, ref _rightHeldState);
					UpdateHeldHand(rigManager.physicsRig.rightHand, _playerRightHandTransform, _cloneRightHandTransform, ref _rightHeldState, ref _leftHeldState);
				}
			}
		}

		private static void UpdateHeldHand(Hand hand, Transform playerHandBone, Transform cloneHandBone, ref HeldItemState state, ref HeldItemState otherState)
		{
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_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_0106: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerHandBone == (Object)null || (Object)(object)cloneHandBone == (Object)null)
			{
				if ((Object)(object)state.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref state);
				}
				return;
			}
			GameObject val = ResolveHeldItemRoot(hand);
			if ((Object)(object)val == (Object)null)
			{
				if ((Object)(object)state.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref state);
				}
				return;
			}
			int instanceID = ((Object)val).GetInstanceID();
			if (_claimedRootIds.Contains(instanceID))
			{
				if ((Object)(object)state.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref state);
				}
				return;
			}
			_claimedRootIds.Add(instanceID);
			if (state.PlayerItemId != instanceID || (Object)(object)state.CloneVisual == (Object)null)
			{
				if ((Object)(object)state.CloneVisual != (Object)null)
				{
					TearDownHeldVisual(ref state);
				}
				GameObject val2 = BuildHeldVisual(val);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				state.PlayerItemId = instanceID;
				state.CloneVisual = val2;
				state.PlayerSourceRoot = val;
				state.PersistentSync = null;
			}
			Transform transform = val.transform;
			Vector3 localPosition = playerHandBone.InverseTransformPoint(transform.position);
			Quaternion localRotation = Quaternion.Inverse(playerHandBone.rotation) * transform.rotation;
			Transform transform2 = state.CloneVisual.transform;
			if ((Object)(object)transform2.parent != (Object)(object)cloneHandBone)
			{
				try
				{
					transform2.SetParent(cloneHandBone, false);
				}
				catch
				{
				}
			}
			transform2.localPosition = localPosition;
			transform2.localRotation = localRotation;
			Vector3 lossyScale = transform.lossyScale;
			Vector3 lossyScale2 = cloneHandBone.lossyScale;
			float num = Mathf.Abs(lossyScale2.x);
			if (num < 0.0001f)
			{
				num = 1f;
			}
			float num2 = Mathf.Abs(lossyScale2.y);
			if (num2 < 0.0001f)
			{
				num2 = 1f;
			}
			float num3 = Mathf.Abs(lossyScale2.z);
			if (num3 < 0.0001f)
			{
				num3 = 1f;
			}
			transform2.localScale = new Vector3(lossyScale.x / num, lossyScale.y / num2, lossyScale.z / num3);
			if (!state.CloneVisual.activeSelf)
			{
				state.CloneVisual.SetActive(true);
			}
			ApplyPersistentItemUpdate(state.PlayerSourceRoot, state.CloneVisual, ref state.PersistentSync);
		}

		private static bool ShouldMirrorPoolee(Poolee poolee, GameObject pgo, int localRigId)
		{
			if ((Object)(object)poolee == (Object)null || (Object)(object)pgo == (Object)null)
			{
				return false;
			}
			if (localRigId != 0 && ((Object)pgo).GetInstanceID() == localRigId)
			{
				return false;
			}
			try
			{
				if ((Object)(object)poolee.SpawnableCrate == (Object)null)
				{
					return false;
				}
			}
			catch
			{
				return false;
			}
			try
			{
				if ((Object)(object)pgo.GetComponent<RigManager>() != (Object)null)
				{
					return false;
				}
			}
			catch
			{
			}
			try
			{
				string iD = ((Scannable)poolee.SpawnableCrate).Barcode.ID;
				if (!string.IsNullOrEmpty(iD) && _mirrorBlacklistBarcodes.Contains(iD))
				{
					return false;
				}
			}
			catch
			{
			}
			return true;
		}

		private static GameObject ResolveHeldItemRoot(Hand hand)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)hand == (Object)null)
			{
				return null;
			}
			GameObject val = null;
			try
			{
				val = hand.m_CurrentAttachedGO;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Poolee val2 = null;
			try
			{
				val2 = val.GetComponentInParent<Poolee>();
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObject val3 = null;
			try
			{
				val3 = ((Component)val2).gameObject;
			}
			catch
			{
			}
			if ((Object)(object)val3 == (Object)null)
			{
				return null;
			}
			int localRigId = 0;
			try
			{
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager != (Object)null)
				{
					localRigId = ((Object)((Component)rigManager).gameObject).GetInstanceID();
				}
			}
			catch
			{
			}
			if (!ShouldMirrorPoolee(val2, val3, localRigId))
			{
				return null;
			}
			return val3;
		}

		private static GameObject BuildHeldVisual(GameObject src)
		{
			if ((Object)(object)src == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject obj = Object.Instantiate<GameObject>(src);
				((Object)obj).name = ((Object)src).name + " (LocalMirrorHeld)";
				Object.DontDestroyOnLoad((Object)(object)obj);
				StripHeldVisual(obj);
				ForceRenderingOnAll(obj);
				return obj;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] BuildHeldVisual threw: " + ex.Message);
				return null;
			}
		}

		private static void StripHeldVisual(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			try
			{
				Il2CppArrayBase<Joint> componentsInChildren = root.GetComponentsInChildren<Joint>(true);
				if (componentsInChildren != null)
				{
					for (int i = 0; i < componentsInChildren.Count; i++)
					{
						Joint val = componentsInChildren[i];
						if (!((Object)(object)val == (Object)null))
						{
							try
							{
								Object.Destroy((Object)(object)val);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Grip> componentsInChildren2 = root.GetComponentsInChildren<Grip>(true);
				if (componentsInChildren2 != null)
				{
					for (int j = 0; j < componentsInChildren2.Count; j++)
					{
						Grip val2 = componentsInChildren2[j];
						if (!((Object)(object)val2 == (Object)null))
						{
							try
							{
								Object.Destroy((Object)(object)val2);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<InteractableHost> componentsInChildren3 = root.GetComponentsInChildren<InteractableHost>(true);
				if (componentsInChildren3 != null)
				{
					for (int k = 0; k < componentsInChildren3.Count; k++)
					{
						InteractableHost val3 = componentsInChildren3[k];
						if (!((Object)(object)val3 == (Object)null))
						{
							try
							{
								Object.Destroy((Object)(object)val3);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Rigidbody> componentsInChildren4 = root.GetComponentsInChildren<Rigidbody>(true);
				if (componentsInChildren4 != null)
				{
					for (int l = 0; l < componentsInChildren4.Count; l++)
					{
						Rigidbody val4 = componentsInChildren4[l];
						if (!((Object)(object)val4 == (Object)null))
						{
							try
							{
								val4.isKinematic = true;
							}
							catch
							{
							}
							try
							{
								val4.detectCollisions = false;
							}
							catch
							{
							}
							try
							{
								Object.Destroy((Object)(object)val4);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Collider> componentsInChildren5 = root.GetComponentsInChildren<Collider>(true);
				if (componentsInChildren5 != null)
				{
					for (int m = 0; m < componentsInChildren5.Count; m++)
					{
						Collider val5 = componentsInChildren5[m];
						if (!((Object)(object)val5 == (Object)null))
						{
							try
							{
								Object.Destroy((Object)(object)val5);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<AudioSource> componentsInChildren6 = root.GetComponentsInChildren<AudioSource>(true);
				if (componentsInChildren6 != null)
				{
					for (int n = 0; n < componentsInChildren6.Count; n++)
					{
						AudioSource val6 = componentsInChildren6[n];
						if (!((Object)(object)val6 == (Object)null))
						{
							try
							{
								val6.Stop();
							}
							catch
							{
							}
							try
							{
								Object.Destroy((Object)(object)val6);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Light> componentsInChildren7 = root.GetComponentsInChildren<Light>(true);
				if (componentsInChildren7 != null)
				{
					for (int num = 0; num < componentsInChildren7.Count; num++)
					{
						Light val7 = componentsInChildren7[num];
						if (!((Object)(object)val7 == (Object)null))
						{
							try
							{
								Object.Destroy((Object)(object)val7);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Poolee> componentsInChildren8 = root.GetComponentsInChildren<Poolee>(true);
				if (componentsInChildren8 == null)
				{
					return;
				}
				for (int num2 = 0; num2 < componentsInChildren8.Count; num2++)
				{
					Poolee val8 = componentsInChildren8[num2];
					if (!((Object)(object)val8 == (Object)null))
					{
						try
						{
							Object.Destroy((Object)(object)val8);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void ForceRenderingOnAll(GameObject root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			try
			{
				Il2CppArrayBase<Renderer> componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren == null)
				{
					return;
				}
				int count = componentsInChildren.Count;
				for (int i = 0; i < count; i++)
				{
					Renderer val = componentsInChildren[i];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						if (val.forceRenderingOff)
						{
							val.forceRenderingOff = false;
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
		}

		private static void TearDownHeldVisual(ref HeldItemState state)
		{
			if ((Object)(object)state.CloneVisual != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)state.CloneVisual);
				}
				catch
				{
				}
			}
			state.CloneVisual = null;
			state.PlayerItemId = 0;
			state.PlayerSourceRoot = null;
			state.PersistentSync = null;
		}

		private static void SyncSeatMirror()
		{
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: 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_01f6: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorSeatAwarenessEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if ((Object)(object)_seatedState.CloneVisual != (Object)null)
				{
					TearDownSeatVisual();
				}
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)rigManager.avatar).transform;
			Transform val = null;
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						val = child;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Seat val2 = null;
			try
			{
				val2 = rigManager.activeSeat;
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				if ((Object)(object)_seatedState.CloneVisual != (Object)null)
				{
					TearDownSeatVisual();
				}
				return;
			}
			GameObject val3 = ResolveSeatSpawnableRoot(val2);
			if ((Object)(object)val3 == (Object)null)
			{
				if ((Object)(object)_seatedState.CloneVisual != (Object)null)
				{
					TearDownSeatVisual();
				}
				return;
			}
			int instanceID = ((Object)val3).GetInstanceID();
			if (_claimedRootIds.Contains(instanceID))
			{
				if ((Object)(object)_seatedState.CloneVisual != (Object)null)
				{
					TearDownSeatVisual();
				}
				return;
			}
			_claimedRootIds.Add(instanceID);
			if (_seatedState.PlayerSeatRootId != instanceID || (Object)(object)_seatedState.CloneVisual == (Object)null)
			{
				if ((Object)(object)_seatedState.CloneVisual != (Object)null)
				{
					TearDownSeatVisual();
				}
				GameObject val4 = BuildHeldVisual(val3);
				if ((Object)(object)val4 == (Object)null)
				{
					return;
				}
				_seatedState.PlayerSeatRootId = instanceID;
				_seatedState.CloneVisual = val4;
				_seatedState.PlayerSourceRoot = val3;
				_seatedState.PersistentSync = null;
			}
			Transform transform2 = val3.transform;
			Vector3 localPosition = transform.InverseTransformPoint(transform2.position);
			Quaternion localRotation = Quaternion.Inverse(transform.rotation) * transform2.rotation;
			Transform transform3 = _seatedState.CloneVisual.transform;
			if ((Object)(object)transform3.parent != (Object)(object)val)
			{
				try
				{
					transform3.SetParent(val, false);
				}
				catch
				{
				}
			}
			transform3.localPosition = localPosition;
			transform3.localRotation = localRotation;
			Vector3 lossyScale = transform2.lossyScale;
			Vector3 lossyScale2 = val.lossyScale;
			float num = Mathf.Abs(lossyScale2.x);
			if (num < 0.0001f)
			{
				num = 1f;
			}
			float num2 = Mathf.Abs(lossyScale2.y);
			if (num2 < 0.0001f)
			{
				num2 = 1f;
			}
			float num3 = Mathf.Abs(lossyScale2.z);
			if (num3 < 0.0001f)
			{
				num3 = 1f;
			}
			transform3.localScale = new Vector3(lossyScale.x / num, lossyScale.y / num2, lossyScale.z / num3);
			if (!_seatedState.CloneVisual.activeSelf)
			{
				_seatedState.CloneVisual.SetActive(true);
			}
			ApplyPersistentItemUpdate(_seatedState.PlayerSourceRoot, _seatedState.CloneVisual, ref _seatedState.PersistentSync);
		}

		private static GameObject ResolveSeatSpawnableRoot(Seat seat)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)seat == (Object)null)
			{
				return null;
			}
			GameObject val = null;
			try
			{
				val = ((Component)seat).gameObject;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Poolee val2 = null;
			try
			{
				val2 = val.GetComponentInParent<Poolee>();
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			GameObject val3 = null;
			try
			{
				val3 = ((Component)val2).gameObject;
			}
			catch
			{
			}
			if ((Object)(object)val3 == (Object)null)
			{
				return null;
			}
			int localRigId = 0;
			try
			{
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager != (Object)null)
				{
					localRigId = ((Object)((Component)rigManager).gameObject).GetInstanceID();
				}
			}
			catch
			{
			}
			if (!ShouldMirrorPoolee(val2, val3, localRigId))
			{
				return null;
			}
			return val3;
		}

		private static void TearDownSeatVisual()
		{
			if ((Object)(object)_seatedState.CloneVisual != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)_seatedState.CloneVisual);
				}
				catch
				{
				}
			}
			_seatedState.CloneVisual = null;
			_seatedState.PlayerSeatRootId = 0;
			_seatedState.PlayerSourceRoot = null;
			_seatedState.PersistentSync = null;
		}

		private static void SyncRemoteRigClones()
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorIncludeOthersEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if (_remoteRigClones.Count > 0)
				{
					ClearRemoteRigClones();
				}
				return;
			}
			bool flag2 = false;
			try
			{
				flag2 = IsFusionLoaded();
			}
			catch
			{
			}
			if (!flag2)
			{
				if (_remoteRigClones.Count > 0)
				{
					ClearRemoteRigClones();
				}
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
			{
				if (_remoteRigClones.Count > 0)
				{
					ClearRemoteRigClones();
				}
				return;
			}
			Transform transform = ((Component)rigManager.avatar).transform;
			Transform val = null;
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						val = child;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			float num = 0f;
			try
			{
				num = Time.realtimeSinceStartup;
			}
			catch
			{
			}
			bool flag3 = false;
			try
			{
				flag3 = Config.LocalMirrorProximityAwarenessEnabled.Value;
			}
			catch
			{
			}
			if ((flag3 || _remoteRigClones.Count > 0 || _remoteScanForcedOnce) && num >= _remoteEligibilityNextTime)
			{
				_remoteEligibilityNextTime = num + 0.1f;
				bool num2 = flag3 || _remoteScanForcedOnce;
				_remoteScanForcedOnce = false;
				if (num2)
				{
					ScanRemoteRigEligibility(rigManager, transform, val, num);
				}
				else
				{
					QuickHeldOnlyMaintenance(rigManager, num);
				}
			}
			List<int> list = null;
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
			{
				RemoteRigClone value = remoteRigClone.Value;
				if (value == null || (Object)value.SourceAvatarT == (Object)null || (Object)value.Visual == (Object)null)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(remoteRigClone.Key);
					continue;
				}
				try
				{
					UpdateRemoteRigClone(value, transform, val);
				}
				catch (Exception ex)
				{
					RemoteWarn($"update threw for rigId={remoteRigClone.Key}: {ex.Message}");
				}
			}
			if (list == null)
			{
				return;
			}
			for (int j = 0; j < list.Count; j++)
			{
				int key = list[j];
				if (_remoteRigClones.TryGetValue(key, out var value2) && value2 != null && (Object)(object)value2.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value2.Visual);
					}
					catch
					{
					}
				}
				_remoteRigClones.Remove(key);
			}
		}

		private static void QuickHeldOnlyMaintenance(RigManager rm, float now)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorHeldItemAwarenessEnabled.Value;
			}
			catch
			{
			}
			int instanceID = ((Object)((Component)rm).gameObject).GetInstanceID();
			int num = 0;
			int num2 = 0;
			if (flag && (Object)(object)rm.physicsRig != (Object)null)
			{
				num = TryResolveHeldRigId(rm.physicsRig.leftHand, instanceID);
				num2 = TryResolveHeldRigId(rm.physicsRig.rightHand, instanceID);
			}
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
			{
				RemoteRigClone value = remoteRigClone.Value;
				if (value != null && flag && (value.SourceRigId == num || value.SourceRigId == num2))
				{
					value.LastHeldTime = now;
				}
			}
			List<int> list = null;
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone2 in _remoteRigClones)
			{
				RemoteRigClone value2 = remoteRigClone2.Value;
				if (value2 == null || (Object)value2.SourceRig == (Object)null || (Object)value2.Visual == (Object)null)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(remoteRigClone2.Key);
					continue;
				}
				bool num3 = now - value2.LastProxTime <= 0.5f;
				bool flag2 = now - value2.LastHeldTime <= 0.25f;
				if (!num3 && !flag2)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(remoteRigClone2.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				int key = list[i];
				if (_remoteRigClones.TryGetValue(key, out var value3) && value3 != null && (Object)(object)value3.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value3.Visual);
					}
					catch
					{
					}
				}
				_remoteRigClones.Remove(key);
			}
		}

		private static void ScanRemoteRigEligibility(RigManager rm, Transform playerAvatarT, Transform cloneAvatarT, float now)
		{
			//IL_00b4: 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_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Expected O, but got Unknown
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_01a4: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)((Component)rm).gameObject).GetInstanceID();
			bool flag = false;
			float num = 0f;
			try
			{
				flag = Config.LocalMirrorProximityAwarenessEnabled.Value;
			}
			catch
			{
			}
			if (flag)
			{
				try
				{
					num = Config.LocalMirrorProximityRadius.Value;
				}
				catch
				{
				}
				if (num <= 0.0001f)
				{
					flag = false;
				}
			}
			bool flag2 = false;
			try
			{
				flag2 = Config.LocalMirrorHeldItemAwarenessEnabled.Value;
			}
			catch
			{
			}
			if (!flag && !flag2)
			{
				if (_remoteRigClones.Count > 0)
				{
					ClearRemoteRigClones();
				}
				return;
			}
			Vector3 val2;
			try
			{
				Transform val = (((Object)(object)rm.physicsRig != (Object)null) ? ((Component)((Rig)rm.physicsRig).m_chest).transform : null);
				val2 = (((Object)(object)val != (Object)null) ? val.position : playerAvatarT.position);
			}
			catch
			{
				val2 = playerAvatarT.position;
			}
			if (flag2 && (Object)(object)rm.physicsRig != (Object)null)
			{
				TryResolveHeldRigId(rm.physicsRig.leftHand, instanceID);
				TryResolveHeldRigId(rm.physicsRig.rightHand, instanceID);
			}
			Dictionary<int, (RigManager, bool, bool)> dictionary = new Dictionary<int, (RigManager, bool, bool)>();
			if (flag)
			{
				HashSet<NetworkPlayer> players = NetworkPlayer.Players;
				if (players != null)
				{
					foreach (NetworkPlayer item in players)
					{
						if (item == null || !item.HasRig)
						{
							continue;
						}
						RigRefs rigRefs = item.RigRefs;
						if (rigRefs == null)
						{
							continue;
						}
						RigManager rigManager = rigRefs.RigManager;
						if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
						{
							continue;
						}
						int instanceID2 = ((Object)((Component)rigManager).gameObject).GetInstanceID();
						if (instanceID2 == instanceID)
						{
							continue;
						}
						Vector3 val4;
						try
						{
							Transform val3 = (((Object)(object)rigManager.physicsRig != (Object)null) ? ((Component)((Rig)rigManager.physicsRig).m_chest).transform : null);
							val4 = (((Object)(object)val3 != (Object)null) ? val3.position : ((Component)rigManager.avatar).transform.position);
						}
						catch
						{
							try
							{
								val4 = ((Component)rigManager.avatar).transform.position;
								goto end_IL_01d8;
							}
							catch
							{
							}
							continue;
							end_IL_01d8:;
						}
						Vector3 val5 = val4 - val2;
						if (!(((Vector3)(ref val5)).sqrMagnitude > num * num) && !dictionary.ContainsKey(instanceID2))
						{
							dictionary[instanceID2] = (rigManager, true, false);
						}
					}
				}
			}
			if (flag2 && (Object)(object)rm.physicsRig != (Object)null)
			{
				AddHeldRigToEligible(rm.physicsRig.leftHand, instanceID, dictionary);
				AddHeldRigToEligible(rm.physicsRig.rightHand, instanceID, dictionary);
			}
			HashSet<int> hashSet = new HashSet<int>();
			foreach (KeyValuePair<int, (RigManager, bool, bool)> item2 in dictionary)
			{
				int key = item2.Key;
				(RigManager, bool, bool) value = item2.Value;
				hashSet.Add(key);
				if (_remoteRigClones.TryGetValue(key, out var value2))
				{
					if (value2 != null)
					{
						if (value.Item2)
						{
							value2.LastProxTime = now;
						}
						if (value.Item3)
						{
							value2.LastHeldTime = now;
						}
					}
					continue;
				}
				try
				{
					RemoteRigClone remoteRigClone = BuildRemoteRigClone(value.Item1, cloneAvatarT);
					if (remoteRigClone != null)
					{
						if (value.Item2)
						{
							remoteRigClone.LastProxTime = now;
						}
						if (value.Item3)
						{
							remoteRigClone.LastHeldTime = now;
						}
						_remoteRigClones[key] = remoteRigClone;
					}
					else
					{
						RemoteWarn($"BuildRemoteRigClone returned null for rigId={key}");
					}
				}
				catch (Exception ex)
				{
					RemoteWarn($"build threw for rigId={key}: {ex.Message}");
				}
			}
			List<int> list = null;
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone2 in _remoteRigClones)
			{
				if (hashSet.Contains(remoteRigClone2.Key))
				{
					continue;
				}
				RemoteRigClone value3 = remoteRigClone2.Value;
				if (value3 == null || (Object)value3.SourceRig == (Object)null || (Object)value3.Visual == (Object)null)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(remoteRigClone2.Key);
					continue;
				}
				bool num2 = now - value3.LastProxTime <= 0.5f;
				bool flag3 = now - value3.LastHeldTime <= 0.25f;
				if (!num2 && !flag3)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(remoteRigClone2.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				int key2 = list[i];
				if (_remoteRigClones.TryGetValue(key2, out var value4) && value4 != null && (Object)(object)value4.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value4.Visual);
					}
					catch
					{
					}
				}
				_remoteRigClones.Remove(key2);
			}
		}

		private static void AddHeldRigToEligible(Hand hand, int localRigId, Dictionary<int, (RigManager rig, bool prox, bool held)> eligibleRigs)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)hand == (Object)null)
			{
				return;
			}
			GameObject val = null;
			try
			{
				val = hand.m_CurrentAttachedGO;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			RigManager val2 = null;
			try
			{
				val2 = val.GetComponentInParent<RigManager>();
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)((Component)val2).gameObject).GetInstanceID();
			if (instanceID != localRigId && !((Object)(object)val2.avatar == (Object)null))
			{
				if (eligibleRigs.TryGetValue(instanceID, out (RigManager, bool, bool) value))
				{
					eligibleRigs[instanceID] = (value.Item1, value.Item2, true);
				}
				else
				{
					eligibleRigs[instanceID] = (val2, false, true);
				}
			}
		}

		private static int TryResolveHeldRigId(Hand hand, int localRigId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)hand == (Object)null)
			{
				return 0;
			}
			GameObject val = null;
			try
			{
				val = hand.m_CurrentAttachedGO;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			RigManager val2 = null;
			try
			{
				val2 = val.GetComponentInParent<RigManager>();
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return 0;
			}
			int instanceID = ((Object)((Component)val2).gameObject).GetInstanceID();
			if (instanceID == localRigId)
			{
				return 0;
			}
			return instanceID;
		}

		private static RemoteRigClone BuildRemoteRigClone(RigManager source, Transform cloneAvatarT)
		{
			if ((Object)(object)source == (Object)null || (Object)(object)source.avatar == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)source.avatar).transform;
			if ((Object)(object)transform == (Object)null)
			{
				return null;
			}
			GameObject val = null;
			try
			{
				val = Object.Instantiate<GameObject>(((Component)transform).gameObject);
			}
			catch (Exception ex)
			{
				RemoteWarn("Instantiate threw: " + ex.Message);
				return null;
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				Object.DontDestroyOnLoad((Object)(object)val);
			}
			catch
			{
			}
			try
			{
				((Object)val).name = "LocalMirror_RemoteRigClone(" + ((Object)source).name + ")";
			}
			catch
			{
			}
			StripHeldVisual(val);
			ForceRenderingOnAll(val);
			bool functional = false;
			try
			{
				functional = IsAvatarFunctional(transform);
			}
			catch
			{
			}
			RemoteRigClone remoteRigClone = new RemoteRigClone
			{
				SourceRig = source,
				SourceRigId = ((Object)((Component)source).gameObject).GetInstanceID(),
				Visual = val,
				SourceAvatarT = transform,
				Functional = functional
			};
			BuildRemoteBoneMap(transform, val.transform, remoteRigClone.SrcBones, remoteRigClone.DstBones);
			BuildRemoteRendererPairs(transform, val.transform, remoteRigClone.RendererPairs);
			try
			{
				val.transform.SetParent(cloneAvatarT, false);
			}
			catch
			{
			}
			try
			{
				Avatar component = val.GetComponent<Avatar>();
				if ((Object)(object)component != (Object)null)
				{
					component.eyeOffset = 0f;
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<Grip> componentsInChildren = val.GetComponentsInChildren<Grip>(true);
				if (componentsInChildren != null)
				{
					int count = componentsInChildren.Count;
					for (int i = 0; i < count; i++)
					{
						Grip val2 = componentsInChildren[i];
						if ((Object)(object)val2 != (Object)null)
						{
							try
							{
								((Behaviour)val2).enabled = false;
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			if (!val.activeSelf)
			{
				try
				{
					val.SetActive(true);
				}
				catch
				{
				}
			}
			return remoteRigClone;
		}

		private static void BuildRemoteBoneMap(Transform src, Transform dst, List<Transform> srcBones, List<Transform> dstBones)
		{
			srcBones.Clear();
			dstBones.Clear();
			BuildRemoteBoneMapInternal(src, dst, srcBones, dstBones);
		}

		private static void BuildRemoteBoneMapInternal(Transform src, Transform dst, List<Transform> srcBones, List<Transform> dstBones)
		{
			if ((Object)(object)src == (Object)null || (Object)(object)dst == (Object)null)
			{
				return;
			}
			int childCount = src.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child = src.GetChild(i);
				if (!((Object)(object)child == (Object)null))
				{
					Transform val = dst.Find(((Object)child).name);
					if (!((Object)(object)val == (Object)null))
					{
						srcBones.Add(child);
						dstBones.Add(val);
						BuildRemoteBoneMapInternal(child, val, srcBones, dstBones);
					}
				}
			}
		}

		private static void BuildRemoteRendererPairs(Transform srcRoot, Transform dstRoot, List<(SkinnedMeshRenderer, SkinnedMeshRenderer)> outPairs)
		{
			outPairs.Clear();
			if ((Object)(object)srcRoot == (Object)null || (Object)(object)dstRoot == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren = ((Component)srcRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren2 = ((Component)dstRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			if (componentsInChildren == null || componentsInChildren2 == null)
			{
				return;
			}
			Dictionary<string, SkinnedMeshRenderer> dictionary = new Dictionary<string, SkinnedMeshRenderer>();
			for (int i = 0; i < componentsInChildren.Count; i++)
			{
				SkinnedMeshRenderer val = componentsInChildren[i];
				if (!((Object)(object)val == (Object)null))
				{
					string text = null;
					try
					{
						text = ((Object)((Component)val).gameObject).name;
					}
					catch
					{
					}
					if (!string.IsNullOrEmpty(text) && !dictionary.ContainsKey(text))
					{
						dictionary[text] = val;
					}
				}
			}
			for (int j = 0; j < componentsInChildren2.Count; j++)
			{
				SkinnedMeshRenderer val2 = componentsInChildren2[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					string text2 = null;
					try
					{
						text2 = ((Object)((Component)val2).gameObject).name;
					}
					catch
					{
					}
					if (!string.IsNullOrEmpty(text2) && dictionary.TryGetValue(text2, out var value) && !((Object)(object)value == (Object)null))
					{
						outPairs.Add((value, val2));
					}
				}
			}
		}

		private static void UpdateRemoteRigClone(RemoteRigClone st, Transform playerAvatarT, Transform cloneAvatarT)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00cd: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			if (st == null || (Object)(object)st.SourceAvatarT == (Object)null || (Object)(object)st.Visual == (Object)null || (Object)(object)playerAvatarT == (Object)null || (Object)(object)cloneAvatarT == (Object)null)
			{
				return;
			}
			Transform transform = st.Visual.transform;
			if ((Object)(object)transform.parent != (Object)(object)cloneAvatarT)
			{
				try
				{
					transform.SetParent(cloneAvatarT, false);
				}
				catch
				{
				}
			}
			Vector3 position = st.SourceAvatarT.position;
			Quaternion rotation = st.SourceAvatarT.rotation;
			Vector3 localPosition = playerAvatarT.InverseTransformPoint(position);
			Quaternion localRotation = Quaternion.Inverse(playerAvatarT.rotation) * rotation;
			transform.localPosition = localPosition;
			transform.localRotation = localRotation;
			Vector3 lossyScale = st.SourceAvatarT.lossyScale;
			Vector3 lossyScale2 = cloneAvatarT.lossyScale;
			float num = Mathf.Abs(lossyScale2.x);
			if (num < 0.0001f)
			{
				num = 1f;
			}
			float num2 = Mathf.Abs(lossyScale2.y);
			if (num2 < 0.0001f)
			{
				num2 = 1f;
			}
			float num3 = Mathf.Abs(lossyScale2.z);
			if (num3 < 0.0001f)
			{
				num3 = 1f;
			}
			transform.localScale = new Vector3(lossyScale.x / num, lossyScale.y / num2, lossyScale.z / num3);
			st.FrameCounter++;
			bool flag = st.Functional && st.FrameCounter % 6 == 0;
			int count = st.SrcBones.Count;
			for (int i = 0; i < count; i++)
			{
				Transform val = st.SrcBones[i];
				Transform val2 = st.DstBones[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
				{
					val2.localPosition = val.localPosition;
					val2.localRotation = val.localRotation;
					val2.localScale = val.localScale;
				}
			}
			int count2 = st.RendererPairs.Count;
			for (int j = 0; j < count2; j++)
			{
				var (val3, val4) = st.RendererPairs[j];
				if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					continue;
				}
				bool flag2 = true;
				try
				{
					flag2 = ((Renderer)val3).enabled;
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val4).enabled != flag2)
					{
						((Renderer)val4).enabled = flag2;
					}
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val4).forceRenderingOff)
					{
						((Renderer)val4).forceRenderingOff = false;
					}
				}
				catch
				{
				}
				if (!flag)
				{
					continue;
				}
				try
				{
					Mesh sharedMesh = val3.sharedMesh;
					if (!((Object)(object)sharedMesh != (Object)null) || !((Object)(object)val4.sharedMesh != (Object)null))
					{
						continue;
					}
					int blendShapeCount = sharedMesh.blendShapeCount;
					for (int k = 0; k < blendShapeCount; k++)
					{
						float blendShapeWeight;
						try
						{
							blendShapeWeight = val3.GetBlendShapeWeight(k);
						}
						catch
						{
							continue;
						}
						float blendShapeWeight2;
						try
						{
							blendShapeWeight2 = val4.GetBlendShapeWeight(k);
						}
						catch
						{
							continue;
						}
						if (Mathf.Abs(blendShapeWeight2 - blendShapeWeight) > 0.001f)
						{
							try
							{
								val4.SetBlendShapeWeight(k, blendShapeWeight);
							}
							catch
							{
							}
						}
					}
				}
				catch
				{
				}
			}
			if (!flag)
			{
				return;
			}
			for (int l = 0; l < count; l++)
			{
				Transform val5 = st.SrcBones[l];
				Transform val6 = st.DstBones[l];
				if ((Object)(object)val5 == (Object)null || (Object)(object)val6 == (Object)null)
				{
					continue;
				}
				try
				{
					bool activeSelf = ((Component)val5).gameObject.activeSelf;
					if (((Component)val6).gameObject.activeSelf != activeSelf)
					{
						((Component)val6).gameObject.SetActive(activeSelf);
					}
				}
				catch
				{
				}
			}
		}

		private static void ClearRemoteRigClones()
		{
			if (_remoteRigClones.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
			{
				RemoteRigClone value = remoteRigClone.Value;
				if (value != null && (Object)(object)value.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value.Visual);
					}
					catch
					{
					}
				}
			}
			_remoteRigClones.Clear();
		}

		private static void SyncHolsteredItems()
		{
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorShowHolsteredEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if (_localHolsterVisuals.Count > 0)
				{
					ClearLocalHolsterVisuals();
				}
				{
					foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
					{
						RemoteRigClone value = remoteRigClone.Value;
						if (value != null && value.HolsterVisuals != null && value.HolsterVisuals.Count > 0)
						{
							ClearHolsterDictionary(value.HolsterVisuals);
						}
					}
					return;
				}
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null || (Object)(object)rigManager.physicsRig == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)rigManager.avatar).transform;
			Transform val = null;
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						val = child;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			SyncRigHolsterVisuals(rigManager, transform, val, _localHolsterVisuals);
			bool flag2 = false;
			try
			{
				flag2 = Config.LocalMirrorIncludeOthersEnabled.Value;
			}
			catch
			{
			}
			if (flag2)
			{
				foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone2 in _remoteRigClones)
				{
					RemoteRigClone value2 = remoteRigClone2.Value;
					if (value2 != null && !((Object)(object)value2.SourceRig == (Object)null) && !((Object)(object)value2.SourceRig.physicsRig == (Object)null) && !((Object)(object)value2.SourceAvatarT == (Object)null) && !((Object)(object)value2.Visual == (Object)null))
					{
						if (value2.HolsterVisuals == null)
						{
							value2.HolsterVisuals = new Dictionary<int, HolsterVisual>();
						}
						SyncRigHolsterVisuals(value2.SourceRig, value2.SourceAvatarT, value2.Visual.transform, value2.HolsterVisuals);
					}
				}
				return;
			}
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone3 in _remoteRigClones)
			{
				RemoteRigClone value3 = remoteRigClone3.Value;
				if (value3 != null && value3.HolsterVisuals != null && value3.HolsterVisuals.Count > 0)
				{
					ClearHolsterDictionary(value3.HolsterVisuals);
				}
			}
		}

		private static void SyncRigHolsterVisuals(RigManager source, Transform sourceAvatarT, Transform parentT, Dictionary<int, HolsterVisual> visuals)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: 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_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			Il2CppArrayBase<InventorySlotReceiver> componentsInChildren = ((Component)source.physicsRig).GetComponentsInChildren<InventorySlotReceiver>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			HashSet<int> hashSet = new HashSet<int>();
			int count = componentsInChildren.Count;
			for (int i = 0; i < count; i++)
			{
				InventorySlotReceiver val = componentsInChildren[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)(Component)val).GetInstanceID();
				InteractableHost val2 = null;
				try
				{
					IGrippable host = val.GetHost();
					if (host != null)
					{
						val2 = ((Il2CppObjectBase)host).TryCast<InteractableHost>();
					}
				}
				catch
				{
				}
				if ((Object)(object)val2 == (Object)null)
				{
					if (!visuals.TryGetValue(instanceID, out var value) || value == null)
					{
						continue;
					}
					if ((Object)(object)value.Visual != (Object)null)
					{
						try
						{
							Object.Destroy((Object)(object)value.Visual);
						}
						catch
						{
						}
					}
					visuals.Remove(instanceID);
					continue;
				}
				hashSet.Add(instanceID);
				GameObject val3 = null;
				try
				{
					val3 = ((Component)val2).gameObject;
				}
				catch
				{
				}
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				GameObject val4 = val3;
				try
				{
					Poolee componentInParent = val3.GetComponentInParent<Poolee>();
					if ((Object)(object)componentInParent != (Object)null)
					{
						GameObject gameObject = ((Component)componentInParent).gameObject;
						if ((Object)(object)gameObject != (Object)null)
						{
							val4 = gameObject;
						}
					}
				}
				catch
				{
				}
				int instanceID2 = ((Object)(Component)val2).GetInstanceID();
				if (visuals.TryGetValue(instanceID, out var value2) && value2 != null && value2.HostId != instanceID2)
				{
					if ((Object)(object)value2.Visual != (Object)null)
					{
						try
						{
							Object.Destroy((Object)(object)value2.Visual);
						}
						catch
						{
						}
					}
					visuals.Remove(instanceID);
					value2 = null;
				}
				if (value2 == null)
				{
					GameObject val5 = BuildHeldVisual(val4);
					if ((Object)(object)val5 == (Object)null)
					{
						continue;
					}
					value2 = (visuals[instanceID] = new HolsterVisual
					{
						HostId = instanceID2,
						Visual = val5
					});
				}
				Transform transform = val4.transform;
				Vector3 localPosition = sourceAvatarT.InverseTransformPoint(transform.position);
				Quaternion localRotation = Quaternion.Inverse(sourceAvatarT.rotation) * transform.rotation;
				Transform transform2 = value2.Visual.transform;
				if ((Object)(object)transform2.parent != (Object)(object)parentT)
				{
					try
					{
						transform2.SetParent(parentT, false);
					}
					catch
					{
					}
				}
				transform2.localPosition = localPosition;
				transform2.localRotation = localRotation;
				Vector3 lossyScale = transform.lossyScale;
				Vector3 lossyScale2 = parentT.lossyScale;
				float num = Mathf.Abs(lossyScale2.x);
				if (num < 0.0001f)
				{
					num = 1f;
				}
				float num2 = Mathf.Abs(lossyScale2.y);
				if (num2 < 0.0001f)
				{
					num2 = 1f;
				}
				float num3 = Mathf.Abs(lossyScale2.z);
				if (num3 < 0.0001f)
				{
					num3 = 1f;
				}
				transform2.localScale = new Vector3(lossyScale.x / num, lossyScale.y / num2, lossyScale.z / num3);
				if (!value2.Visual.activeSelf)
				{
					try
					{
						value2.Visual.SetActive(true);
					}
					catch
					{
					}
				}
			}
			List<int> list = null;
			foreach (KeyValuePair<int, HolsterVisual> visual in visuals)
			{
				if (!hashSet.Contains(visual.Key))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(visual.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			for (int j = 0; j < list.Count; j++)
			{
				int key = list[j];
				if (visuals.TryGetValue(key, out var value3) && value3 != null && (Object)(object)value3.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value3.Visual);
					}
					catch
					{
					}
				}
				visuals.Remove(key);
			}
		}

		private static void ClearLocalHolsterVisuals()
		{
			ClearHolsterDictionary(_localHolsterVisuals);
		}

		private static void ClearHolsterDictionary(Dictionary<int, HolsterVisual> dict)
		{
			if (dict == null || dict.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<int, HolsterVisual> item in dict)
			{
				HolsterVisual value = item.Value;
				if (value != null && (Object)(object)value.Visual != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)value.Visual);
					}
					catch
					{
					}
				}
			}
			dict.Clear();
		}

		private static void ApplyPersistentItemUpdate(GameObject src, GameObject dst, ref ItemPersistentSync sync)
		{
			if ((Object)(object)src == (Object)null || (Object)(object)dst == (Object)null)
			{
				return;
			}
			if (sync == null)
			{
				sync = new ItemPersistentSync();
			}
			sync.Bones.Clear();
			sync.SkinnedRenderers.Clear();
			sync.MeshRenderers.Clear();
			try
			{
				SkinnedMeshRenderer component = src.GetComponent<SkinnedMeshRenderer>();
				SkinnedMeshRenderer component2 = dst.GetComponent<SkinnedMeshRenderer>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					sync.SkinnedRenderers.Add((component, component2));
				}
			}
			catch
			{
			}
			try
			{
				MeshRenderer component3 = src.GetComponent<MeshRenderer>();
				MeshRenderer component4 = dst.GetComponent<MeshRenderer>();
				if ((Object)(object)component3 != (Object)null && (Object)(object)component4 != (Object)null)
				{
					sync.MeshRenderers.Add((component3, component4));
				}
			}
			catch
			{
			}
			try
			{
				EnsureChildrenMatch(src.transform, dst.transform, sync);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] EnsureChildrenMatch threw: " + ex.Message);
				return;
			}
			SyncItemPersistentState(sync);
		}

		private static void EnsureChildrenMatch(Transform src, Transform dst, ItemPersistentSync sync)
		{
			if ((Object)(object)src == (Object)null || (Object)(object)dst == (Object)null)
			{
				return;
			}
			for (int num = dst.childCount - 1; num >= 0; num--)
			{
				Transform val = null;
				try
				{
					val = dst.GetChild(num);
				}
				catch
				{
					continue;
				}
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Transform val2 = null;
				try
				{
					val2 = src.Find(((Object)val).name);
				}
				catch
				{
				}
				if ((Object)(object)val2 == (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
					catch
					{
					}
				}
			}
			int childCount = src.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform val3 = null;
				try
				{
					val3 = src.GetChild(i);
				}
				catch
				{
					continue;
				}
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				Transform val4 = null;
				try
				{
					val4 = dst.Find(((Object)val3).name);
				}
				catch
				{
				}
				if ((Object)(object)val4 == (Object)null)
				{
					try
					{
						GameObject val5 = Object.Instantiate<GameObject>(((Component)val3).gameObject, dst, false);
						try
						{
							((Object)val5).name = ((Object)val3).name;
						}
						catch
						{
						}
						StripHeldVisual(val5);
						val4 = val5.transform;
					}
					catch (Exception ex)
					{
						MelonLogger.Warning("[LocalMirror] EnsureChildrenMatch instantiate threw: " + ex.Message);
						continue;
					}
				}
				sync.Bones.Add((val3, val4));
				try
				{
					SkinnedMeshRenderer component = ((Component)val3).GetComponent<SkinnedMeshRenderer>();
					SkinnedMeshRenderer component2 = ((Component)val4).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
					{
						sync.SkinnedRenderers.Add((component, component2));
					}
				}
				catch
				{
				}
				try
				{
					MeshRenderer component3 = ((Component)val3).GetComponent<MeshRenderer>();
					MeshRenderer component4 = ((Component)val4).GetComponent<MeshRenderer>();
					if ((Object)(object)component3 != (Object)null && (Object)(object)component4 != (Object)null)
					{
						sync.MeshRenderers.Add((component3, component4));
					}
				}
				catch
				{
				}
				EnsureChildrenMatch(val3, val4, sync);
			}
		}

		private static void SyncItemPersistentState(ItemPersistentSync sync)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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)
			int count = sync.Bones.Count;
			for (int i = 0; i < count; i++)
			{
				var (val, val2) = sync.Bones[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					continue;
				}
				val2.localPosition = val.localPosition;
				val2.localRotation = val.localRotation;
				val2.localScale = val.localScale;
				bool activeSelf;
				try
				{
					activeSelf = ((Component)val).gameObject.activeSelf;
				}
				catch
				{
					continue;
				}
				try
				{
					if (((Component)val2).gameObject.activeSelf != activeSelf)
					{
						((Component)val2).gameObject.SetActive(activeSelf);
					}
				}
				catch
				{
				}
			}
			int count2 = sync.SkinnedRenderers.Count;
			for (int j = 0; j < count2; j++)
			{
				var (val3, val4) = sync.SkinnedRenderers[j];
				if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					continue;
				}
				bool flag = true;
				try
				{
					flag = ((Renderer)val3).enabled;
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val4).enabled != flag)
					{
						((Renderer)val4).enabled = flag;
					}
				}
				catch
				{
				}
				try
				{
					Mesh sharedMesh = val3.sharedMesh;
					if (!((Object)(object)sharedMesh != (Object)null) || !((Object)(object)val4.sharedMesh != (Object)null))
					{
						continue;
					}
					int blendShapeCount = sharedMesh.blendShapeCount;
					for (int k = 0; k < blendShapeCount; k++)
					{
						float blendShapeWeight;
						try
						{
							blendShapeWeight = val3.GetBlendShapeWeight(k);
						}
						catch
						{
							continue;
						}
						float blendShapeWeight2;
						try
						{
							blendShapeWeight2 = val4.GetBlendShapeWeight(k);
						}
						catch
						{
							continue;
						}
						if (Mathf.Abs(blendShapeWeight2 - blendShapeWeight) > 0.001f)
						{
							try
							{
								val4.SetBlendShapeWeight(k, blendShapeWeight);
							}
							catch
							{
							}
						}
					}
				}
				catch
				{
				}
			}
			int count3 = sync.MeshRenderers.Count;
			for (int l = 0; l < count3; l++)
			{
				var (val5, val6) = sync.MeshRenderers[l];
				if ((Object)(object)val5 == (Object)null || (Object)(object)val6 == (Object)null)
				{
					continue;
				}
				bool flag2 = true;
				try
				{
					flag2 = ((Renderer)val5).enabled;
				}
				catch
				{
				}
				try
				{
					if (((Renderer)val6).enabled != flag2)
					{
						((Renderer)val6).enabled = flag2;
					}
				}
				catch
				{
				}
			}
		}

		private static void SyncGameObjectActiveStates()
		{
			if (!_localAvatarFunctional || _localStateSyncFrameCounter % 6 != 0)
			{
				return;
			}
			int count = _srcBones.Count;
			for (int i = 0; i < count; i++)
			{
				Transform val = _srcBones[i];
				Transform val2 = _dstBones[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					continue;
				}
				bool activeSelf;
				try
				{
					activeSelf = ((Component)val).gameObject.activeSelf;
				}
				catch
				{
					continue;
				}
				try
				{
					if (((Component)val2).gameObject.activeSelf != activeSelf)
					{
						((Component)val2).gameObject.SetActive(activeSelf);
					}
				}
				catch
				{
				}
			}
		}

		private static void CopyPose()
		{
			//IL_0054: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			int count = _srcBones.Count;
			for (int i = 0; i < count; i++)
			{
				Transform val = _srcBones[i];
				Transform val2 = _dstBones[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
				{
					if (!_skipPositionCopy.Contains(i))
					{
						val2.localPosition = val.localPosition;
					}
					val2.localRotation = val.localRotation;
					if (!_skipPositionCopy.Contains(i))
					{
						val2.localScale = val.localScale;
					}
				}
			}
			_localStateSyncFrameCounter++;
			SyncGameObjectActiveStates();
			SyncRendererStates();
			SyncFusionCosmetics();
			_claimedRootIds.Clear();
			SyncProximityMirror();
			SyncProximityVisual();
			SyncHeldItemMirror();
			SyncSeatMirror();
			SyncRemoteRigClones();
			SyncHolsteredItems();
		}

		private static void SyncFusionCosmetics()
		{
			bool flag = false;
			try
			{
				flag = Config.ShowFusionCosmeticsEnabled.Value;
			}
			catch
			{
			}
			if (!flag)
			{
				if (_cosmeticMirrorCopies.Count > 0)
				{
					ClearCosmeticMirrorCopies();
				}
				return;
			}
			bool flag2 = false;
			try
			{
				flag2 = IsFusionLoaded();
			}
			catch
			{
			}
			if (!flag2)
			{
				if (_cosmeticMirrorCopies.Count > 0)
				{
					ClearCosmeticMirrorCopies();
				}
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.avatar == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)rigManager.avatar).transform;
			Transform val = null;
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				for (int i = 0; i < _avatarsTran.childCount; i++)
				{
					Transform child = _avatarsTran.GetChild(i);
					if ((Object)(object)child != (Object)null && ((Component)child).gameObject.activeInHierarchy)
					{
						val = child;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				SyncFusionCosmeticsImpl(rigManager, transform, val);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] SyncFusionCosmetics threw: " + ex.Message);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void SyncFusionCosmeticsImpl(RigManager rm, Transform playerAvatarT, Transform cloneAvatarT)
		{
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			IReadOnlyList<PointItem> loadedItems = PointItemManager.LoadedItems;
			if (loadedItems == null)
			{
				return;
			}
			FieldInfo fieldInfo = ResolveAccessoryInstancesField();
			if (fieldInfo == null)
			{
				return;
			}
			Dictionary<int, (Transform, Transform)> dictionary = new Dictionary<int, (Transform, Transform)>();
			dictionary[((Object)rm).GetInstanceID()] = (playerAvatarT, cloneAvatarT);
			bool flag = false;
			try
			{
				flag = Config.LocalMirrorIncludeOthersEnabled.Value;
			}
			catch
			{
			}
			if (flag && _remoteRigClones.Count > 0)
			{
				foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
				{
					RemoteRigClone value = remoteRigClone.Value;
					if (value != null && !((Object)(object)value.SourceRig == (Object)null) && !((Object)(object)value.SourceAvatarT == (Object)null) && !((Object)(object)value.Visual == (Object)null))
					{
						int instanceID = ((Object)value.SourceRig).GetInstanceID();
						if (!dictionary.ContainsKey(instanceID))
						{
							dictionary[instanceID] = (value.SourceAvatarT, value.Visual.transform);
						}
					}
				}
			}
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < loadedItems.Count; i++)
			{
				PointItem val = loadedItems[i];
				if (val == null)
				{
					continue;
				}
				bool flag2 = false;
				try
				{
					flag2 = val.IsEquipped;
				}
				catch
				{
				}
				if (!flag2)
				{
					continue;
				}
				CosmeticItem val2 = (CosmeticItem)(object)((val is CosmeticItem) ? val : null);
				if (val2 == null)
				{
					continue;
				}
				object obj3 = null;
				try
				{
					obj3 = fieldInfo.GetValue(val2);
				}
				catch
				{
				}
				if (obj3 == null || !(obj3 is IDictionary dictionary2))
				{
					continue;
				}
				foreach (DictionaryEntry item in dictionary2)
				{
					object key = item.Key;
					RigManager val3 = (RigManager)((key is RigManager) ? key : null);
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					int instanceID2 = ((Object)val3).GetInstanceID();
					if (!dictionary.TryGetValue(instanceID2, out var value2))
					{
						continue;
					}
					object? value3 = item.Value;
					CosmeticInstance val4 = (CosmeticInstance)((value3 is CosmeticInstance) ? value3 : null);
					if (val4 == null)
					{
						continue;
					}
					GameObject accessory = val4.accessory;
					if ((Object)(object)accessory == (Object)null)
					{
						continue;
					}
					int instanceID3 = ((Object)accessory).GetInstanceID();
					hashSet.Add(instanceID3);
					if (!_cosmeticMirrorCopies.TryGetValue(instanceID3, out var value4) || (Object)(object)value4 == (Object)null)
					{
						try
						{
							value4 = Object.Instantiate<GameObject>(accessory);
							((Object)value4).name = ((Object)accessory).name + " (LocalMirror)";
						}
						catch (Exception ex)
						{
							MelonLogger.Warning("[LocalMirror] Cosmetic instantiate threw: " + ex.Message);
							continue;
						}
						_cosmeticMirrorCopies[instanceID3] = value4;
						try
						{
							Il2CppArrayBase<Grip> componentsInChildren = value4.GetComponentsInChildren<Grip>(true);
							if (componentsInChildren != null)
							{
								for (int j = 0; j < componentsInChildren.Count; j++)
								{
									Grip val5 = componentsInChildren[j];
									if (!((Object)(object)val5 == (Object)null))
									{
										try
										{
											((Behaviour)val5).enabled = false;
										}
										catch
										{
										}
									}
								}
							}
						}
						catch
						{
						}
					}
					Vector3 localPosition = value2.Item1.InverseTransformPoint(accessory.transform.position);
					Quaternion localRotation = Quaternion.Inverse(value2.Item1.rotation) * accessory.transform.rotation;
					Transform transform = value4.transform;
					if ((Object)(object)transform.parent != (Object)(object)value2.Item2)
					{
						try
						{
							transform.SetParent(value2.Item2, false);
						}
						catch
						{
						}
					}
					transform.localPosition = localPosition;
					transform.localRotation = localRotation;
					Vector3 lossyScale = accessory.transform.lossyScale;
					Vector3 lossyScale2 = value2.Item2.lossyScale;
					transform.localScale = new Vector3(lossyScale.x / (Mathf.Approximately(lossyScale2.x, 0f) ? 1f : lossyScale2.x), lossyScale.y / (Mathf.Approximately(lossyScale2.y, 0f) ? 1f : lossyScale2.y), lossyScale.z / (Mathf.Approximately(lossyScale2.z, 0f) ? 1f : lossyScale2.z));
					if (!value4.activeSelf)
					{
						value4.SetActive(true);
					}
				}
			}
			List<int> list = null;
			foreach (KeyValuePair<int, GameObject> cosmeticMirrorCopy in _cosmeticMirrorCopies)
			{
				if (!hashSet.Contains(cosmeticMirrorCopy.Key))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(cosmeticMirrorCopy.Key);
				}
			}
			if (list != null)
			{
				for (int k = 0; k < list.Count; k++)
				{
					int key2 = list[k];
					if (_cosmeticMirrorCopies.TryGetValue(key2, out var value5) && (Object)(object)value5 != (Object)null)
					{
						try
						{
							Object.Destroy((Object)(object)value5);
						}
						catch
						{
						}
					}
					_cosmeticMirrorCopies.Remove(key2);
				}
			}
			try
			{
				SyncRemoteRigCosmetics();
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("[LocalMirror.Cosmetics] SyncRemoteRigCosmetics threw: " + ex2.Message);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void SyncRemoteRigCosmetics()
		{
			if (_remoteRigClones.Count == 0)
			{
				return;
			}
			IReadOnlyList<PointItem> loadedItems = PointItemManager.LoadedItems;
			if (loadedItems == null)
			{
				return;
			}
			FieldInfo fieldInfo = ResolveCosmeticSpawnableCrateRefField();
			if (fieldInfo == null)
			{
				return;
			}
			HashSet<NetworkPlayer> players = NetworkPlayer.Players;
			if (players == null)
			{
				return;
			}
			foreach (KeyValuePair<int, RemoteRigClone> remoteRigClone in _remoteRigClones)
			{
				RemoteRigClone value = remoteRigClone.Value;
				if (value == null || (Object)(object)value.SourceRig == (Object)null || (Object)(object)value.SourceAvatarT == (Object)null || (Object)(object)value.Visual == (Object)null)
				{
					continue;
				}
				if (value.RemoteCosmetics == null)
				{
					value.RemoteCosmetics = new Dictionary<string, GameObject>();
				}
				if (value.RemoteCosmeticsLoading == null)
				{
					value.RemoteCosmeticsLoading = new HashSet<string>();
				}
				int sourceRigId = value.SourceRigId;
				NetworkPlayer val = null;
				try
				{
					foreach (NetworkPlayer item in players)
					{
						if (item == null || !item.HasRig)
						{
							continue;
						}
						RigRefs rigRefs = item.RigRefs;
						if (rigRefs == null)
						{
							continue;
						}
						RigManager rigManager = rigRefs.RigManager;
						if (!((Object)(object)rigManager == (Object)null))
						{
							int num = 0;
							try
							{
								num = ((Object)((Component)rigManager).gameObject).GetInstanceID();
							}
							catch
							{
								continue;
							}
							if (num == sourceRigId)
							{
								val = item;
								break;
							}
						}
					}
				}
				catch
				{
				}
				if (val == null)
				{
					continue;
				}
				PlayerID playerID = val.PlayerID;
				if (playerID == null)
				{
					continue;
				}
				List<string> equippedItems = playerID.EquippedItems;
				if (equippedItems == null)
				{
					continue;
				}
				HashSet<string> hashSet = new HashSet<string>();
				int count = equippedItems.Count;
				for (int i = 0; i < count; i++)
				{
					string text = equippedItems[i];
					if (!string.IsNullOrEmpty(text))
					{
						hashSet.Add(text);
					}
				}
				foreach (string item2 in hashSet)
				{
					CosmeticItem val2 = null;
					try
					{
						for (int j = 0; j < loadedItems.Count; j++)
						{
							PointItem val3 = loadedItems[j];
							if (val3 != null && !(val3.Barcode != item2))
							{
								val2 = (CosmeticItem)(object)((val3 is CosmeticItem) ? val3 : null);
								break;
							}
						}
					}
					catch
					{
					}
					if (val2 != null)
					{
						if (value.RemoteCosmetics.TryGetValue(item2, out var value2) && (Object)(object)value2 != (Object)null)
						{
							UpdateRemoteCosmeticPose(value, val2, value2);
						}
						else if (!value.RemoteCosmeticsLoading.Contains(item2))
						{
							BuildRemoteCosmetic(value, item2, val2, fieldInfo);
						}
					}
				}
				List<string> list = null;
				foreach (KeyValuePair<string, GameObject> remoteCosmetic in value.RemoteCosmetics)
				{
					if (!hashSet.Contains(remoteCosmetic.Key))
					{
						if (list == null)
						{
							list = new List<string>();
						}
						list.Add(remoteCosmetic.Key);
					}
				}
				if (list == null)
				{
					continue;
				}
				for (int k = 0; k < list.Count; k++)
				{
					if (value.RemoteCosmetics.TryGetValue(list[k], out var value3) && (Object)(object)value3 != (Object)null)
					{
						try
						{
							Object.Destroy((Object)(object)value3);
						}
						catch
						{
						}
					}
					value.RemoteCosmetics.Remove(list[k]);
				}
			}
		}

		private static void UpdateRemoteCosmeticPose(RemoteRigClone st, CosmeticItem cosmetic, GameObject visual)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			RigPoint cosmeticPoint;
			try
			{
				cosmeticPoint = cosmetic.Variables.CosmeticPoint;
			}
			catch
			{
				return;
			}
			Vector3 val = default(Vector3);
			Quaternion val2 = default(Quaternion);
			Vector3 val3 = default(Vector3);
			try
			{
				CosmeticItemHelper.GetTransform(cosmeticPoint, st.SourceRig, ref val, ref val2, ref val3);
			}
			catch
			{
				return;
			}
			Transform transform = st.Visual.transform;
			Vector3 localPosition = st.SourceAvatarT.InverseTransformPoint(val);
			Quaternion localRotation = Quaternion.Inverse(st.SourceAvatarT.rotation) * val2;
			Transform transform2 = visual.transform;
			if ((Object)(object)transform2.parent != (Object)(object)transform)
			{
				try
				{
					transform2.SetParent(transform, false);
				}
				catch
				{
				}
			}
			transform2.localPosition = localPosition;
			transform2.localRotation = localRotation;
			Vector3 lossyScale = transform.lossyScale;
			transform2.localScale = new Vector3(val3.x / (Mathf.Approximately(lossyScale.x, 0f) ? 1f : lossyScale.x), val3.y / (Mathf.Approximately(lossyScale.y, 0f) ? 1f : lossyScale.y), val3.z / (Mathf.Approximately(lossyScale.z, 0f) ? 1f : lossyScale.z));
			if (!visual.activeSelf)
			{
				try
				{
					visual.SetActive(true);
				}
				catch
				{
				}
			}
		}

		private static void BuildRemoteCosmetic(RemoteRigClone st, string barcode, CosmeticItem cosmetic, FieldInfo fCrateRef)
		{
			object obj = null;
			try
			{
				obj = fCrateRef.GetValue(cosmetic);
			}
			catch
			{
			}
			SpawnableCrateReference val = (SpawnableCrateReference)((obj is SpawnableCrateReference) ? obj : null);
			if (val == null)
			{
				MelonLogger.Warning("[LocalMirror.Cosmetics] BuildRemoteCosmetic '" + barcode + "': crateRef null (reflection field unwrapped to null/wrong type)");
				return;
			}
			SpawnableCrate val2 = null;
			try
			{
				val2 = ((CrateReferenceT<SpawnableCrate>)(object)val).Crate;
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				MelonLogger.Warning("[LocalMirror.Cosmetics] BuildRemoteCosmetic '" + barcode + "': crateRef.Crate null");
				return;
			}
			MarrowGameObject mainGameObject = ((GameObjectCrate)val2).MainGameObject;
			if ((MarrowAsset)(object)mainGameObject == (MarrowAsset)null)
			{
				MelonLogger.Warning("[LocalMirror.Cosmetics] BuildRemoteCosmetic '" + barcode + "': crate.MainGameObject null");
				return;
			}
			int targetGameObjectId = st.SourceRigId;
			st.RemoteCosmeticsLoading.Add(barcode);
			try
			{
				((MarrowAssetT<GameObject>)(object)mainGameObject).LoadAsset(Action<GameObject>.op_Implicit((Action<GameObject>)delegate(GameObject prefab)
				{
					try
					{
						if (!_remoteRigClones.TryGetValue(targetGameObjectId, out var value) || value != st)
						{
							st.RemoteCosmeticsLoading?.Remove(barcode);
						}
						else
						{
							st.RemoteCosmeticsLoading.Remove(barcode);
							if (!((Object)(object)prefab == (Object)null) && !((Object)(object)st.Visual == (Object)null))
							{
								GameObject val3 = Object.Instantiate<GameObject>(prefab);
								((Object)val3).name = "LocalMirror_RemoteCosmetic(" + barcode + ")";
								try
								{
									Object.DontDestroyOnLoad((Object)(object)val3);
								}
								catch
								{
								}
								StripHeldVisual(val3);
								ForceRenderingOnAll(val3);
								try
								{
									Il2CppArrayBase<Grip> componentsInChildren = val3.GetComponentsInChildren<Grip>(true);
									if (componentsInChildren != null)
									{
										int count = componentsInChildren.Count;
										for (int i = 0; i < count; i++)
										{
											Grip val4 = componentsInChildren[i];
											if ((Object)(object)val4 != (Object)null)
											{
												try
												{
													((Behaviour)val4).enabled = false;
												}
												catch
												{
												}
											}
										}
									}
								}
								catch
								{
								}
								st.RemoteCosmetics[barcode] = val3;
								UpdateRemoteCosmeticPose(st, cosmetic, val3);
							}
						}
					}
					catch (Exception ex2)
					{
						MelonLogger.Warning("[LocalMirror.Cosmetics] BuildRemoteCosmetic callback threw: " + ex2.Message);
					}
				}));
			}
			catch (Exception ex)
			{
				st.RemoteCosmeticsLoading.Remove(barcode);
				MelonLogger.Warning("[LocalMirror.Cosmetics] LoadAsset kickoff threw: " + ex.Message);
			}
		}

		private static FieldInfo ResolveAccessoryInstancesField()
		{
			if (_accessoryInstancesResolveAttempted)
			{
				return _fAccessoryInstances;
			}
			_accessoryInstancesResolveAttempted = true;
			try
			{
				_fAccessoryInstances = typeof(CosmeticItem).GetField("_accessoryInstances", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] ResolveAccessoryInstancesField threw: " + ex.Message);
				_fAccessoryInstances = null;
			}
			return _fAccessoryInstances;
		}

		private static FieldInfo ResolveCosmeticSpawnableCrateRefField()
		{
			if (_cosmeticSpawnableCrateRefResolved)
			{
				return _fCosmeticSpawnableCrateRef;
			}
			_cosmeticSpawnableCrateRefResolved = true;
			try
			{
				_fCosmeticSpawnableCrateRef = typeof(CosmeticItem).GetField("_spawnableCrateReference", BindingFlags.Instance | BindingFlags.NonPublic);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] ResolveCosmeticSpawnableCrateRefField threw: " + ex.Message);
				_fCosmeticSpawnableCrateRef = null;
			}
			return _fCosmeticSpawnableCrateRef;
		}

		private static void ClearCosmeticMirrorCopies()
		{
			foreach (KeyValuePair<int, GameObject> cosmeticMirrorCopy in _cosmeticMirrorCopies)
			{
				if ((Object)(object)cosmeticMirrorCopy.Value != (Object)null)
				{
					try
					{
						Object.Destroy((Object)(object)cosmeticMirrorCopy.Value);
					}
					catch
					{
					}
				}
			}
			_cosmeticMirrorCopies.Clear();
		}

		private static void BuildRig()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			_root = new GameObject("LocalMirror_Root");
			_root.SetActive(false);
			GameObject val = new GameObject("VolumeToReflect");
			val.transform.SetParent(_root.transform, false);
			_volumeTran = val.transform;
			_mirror = val.AddComponent<Mirror>();
			GameObject val2 = new GameObject("AVATARS");
			val2.transform.SetParent(val.transform, false);
			_avatarsTran = val2.transform;
			GameObject val3 = new GameObject("ReflectTran");
			val3.transform.SetParent(_root.transform, false);
			_reflectTran = val3.transform;
			GameObject val4 = new GameObject("ReflectionInitalTran");
			val4.transform.SetParent(_root.transform, false);
			_reflectionInitalTran = val4.transform;
			WireMirrorFields();
			PositionSubTransforms();
			PlaceRootAtAvatarFront();
			_root.SetActive(true);
			TryKickSwap();
			_waitingForClone = true;
		}

		private static void WireMirrorFields()
		{
			if ((Object)(object)_mirror == (Object)null)
			{
				return;
			}
			ResolveAccessors();
			TrySet(_mirror, _fReflectTran, _pReflectTran, _reflectTran);
			TrySet(_mirror, _fReflectionInital, _pReflectionInital, _reflectionInitalTran);
			TrySet(_mirror, _fAvatarsTran, _pAvatarsTran, _avatarsTran);
			try
			{
				RigManager rigManager = Player.RigManager;
				if ((Object)(object)rigManager != (Object)null)
				{
					TrySet(_mirror, _fRigManager, _pRigManager, rigManager);
				}
			}
			catch
			{
			}
			try
			{
				object obj2 = null;
				try
				{
					if (_pCachedReflections != null)
					{
						obj2 = _pCachedReflections.GetValue(_mirror);
					}
				}
				catch
				{
				}
				try
				{
					if (obj2 == null && _fCachedReflections != null)
					{
						obj2 = _fCachedReflections.GetValue(_mirror);
					}
				}
				catch
				{
				}
				if (obj2 != null)
				{
					return;
				}
				Type type = null;
				try
				{
					if (_pCachedReflections != null)
					{
						type = _pCachedReflections.PropertyType;
					}
				}
				catch
				{
				}
				try
				{
					if (type == null && _fCachedReflections != null)
					{
						type = _fCachedReflections.FieldType;
					}
				}
				catch
				{
				}
				if (type != null)
				{
					object obj7 = null;
					try
					{
						obj7 = Activator.CreateInstance(type);
					}
					catch (Exception ex)
					{
						MelonLogger.Warning("[LocalMirror] CreateInstance(" + type.FullName + ") threw: " + ex.Message);
					}
					if (obj7 != null)
					{
						TrySet(_mirror, _fCachedReflections, _pCachedReflections, obj7);
					}
				}
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("[LocalMirror] cache init threw: " + ex2.Message);
			}
		}

		private static void TrySet(object target, FieldInfo f, PropertyInfo p, object value)
		{
			if (f != null)
			{
				try
				{
					f.SetValue(target, value);
					return;
				}
				catch
				{
				}
			}
			if (p != null && p.CanWrite)
			{
				try
				{
					p.SetValue(target, value);
				}
				catch
				{
				}
			}
		}

		private static void ResolveAccessors()
		{
			if (!_accessorsResolved)
			{
				_accessorsResolved = true;
				Type typeFromHandle = typeof(Mirror);
				_fReflectTran = typeFromHandle.GetField("_reflectTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_fReflectionInital = typeFromHandle.GetField("_reflectionInitalTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_fRigManager = typeFromHandle.GetField("rigManager", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_fAvatarsTran = typeFromHandle.GetField("_avatarsTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_fCachedReflections = typeFromHandle.GetField("_cachedReflections", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_pReflectTran = typeFromHandle.GetProperty("_reflectTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_pReflectionInital = typeFromHandle.GetProperty("_reflectionInitalTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_pRigManager = typeFromHandle.GetProperty("rigManager", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_pAvatarsTran = typeFromHandle.GetProperty("_avatarsTran", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_pCachedReflections = typeFromHandle.GetProperty("_cachedReflections", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				_mSwapNoArg = typeFromHandle.GetMethod("SwapReflectionAvatar", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			}
		}

		private static void TryKickSwap()
		{
			if ((Object)(object)_mirror == (Object)null || _mSwapNoArg == null)
			{
				return;
			}
			try
			{
				_mSwapNoArg.Invoke(_mirror, null);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[LocalMirror] SwapReflectionAvatar invoke threw: " + ex.Message);
			}
		}

		private static void PositionSubTransforms()
		{
			//IL_0012: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_volumeTran != (Object)null)
			{
				_volumeTran.localPosition = Vector3.zero;
			}
			if ((Object)(object)_reflectTran != (Object)null)
			{
				_reflectTran.localPosition = Vector3.zero;
			}
			if ((Object)(object)_avatarsTran != (Object)null)
			{
				_avatarsTran.localPosition = Vector3.zero;
			}
			if ((Object)(object)_reflectionInitalTran != (Object)null)
			{
				_reflectionInitalTran.localPosition = Vector3.zero;
			}
		}

		private static void FollowPlayer()
		{
			if (!StayInPlace)
			{
				PlaceRootAtAvatarFront();
			}
			PositionSubTransforms();
		}

		private static float ReadAvatarHeight()
		{
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null)
			{
				return 1.75f;
			}
			try
			{
				float num = 1.75f;
				if ((Object)(object)rigManager.avatar != (Object)null)
				{
					num = rigManager.avatar.height;
				}
				return (num < 0.1f) ? 1.75f : num;
			}
			catch
			{
				return 1.75f;
			}
		}

		private static void PlaceRootAtAvatarFront()
		{
			//IL_008b: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_0189: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null)
			{
				return;
			}
			RigManager rigManager = Player.RigManager;
			if ((Object)(object)rigManager == (Object)null || (Object)(object)rigManager.physicsRig == (Object)null)
			{
				return;
			}
			Transform val = null;
			try
			{
				val = ((Component)((Rig)rigManager.physicsRig).m_head).transform;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = null;
			try
			{
				if ((Object)(object)rigManager.avatar != (Object)null)
				{
					val2 = ((Component)rigManager.avatar).transform;
				}
			}
			catch
			{
			}
			float num = (((Object)(object)val2 != (Object)null) ? val2.position.y : val.position.y);
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(val.position.x, num, val.position.z);
			float num2 = (ScaleByAvatarHeight ? (Distance * (ReadAvatarHeight() / 1.75f)) : Distance);
			Vector3 val4;
			if (FollowHead)
			{
				val4 = val.forward;
				val4.y = 0f;
				if (((Vector3)(ref val4)).sqrMagnitude < 0.0001f)
				{
					val4 = Vector3.forward;
				}
				((Vector3)(ref val4)).Normalize();
				_frozenFwd = null;
			}
			else
			{
				if (!_frozenFwd.HasValue)
				{
					Vector3 forward = val.forward;
					forward.y = 0f;
					if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f)
					{
						forward = Vector3.forward;
					}
					((Vector3)(ref forward)).Normalize();
					_frozenFwd = forward;
				}
				val4 = _frozenFwd.Value;
			}
			_root.transform.SetPositionAndRotation(val3 + val4 * num2, Quaternion.LookRotation(-val4, Vector3.up));
		}

		private static void Cleanup()
		{
			try
			{
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
				}
			}
			catch
			{
			}
			_root = null;
			_volumeTran = null;
			_reflectTran = null;
			_reflectionInitalTran = null;
			_avatarsTran = null;
			_mirror = null;
			_waitingForClone = false;
			_poseCopyActive = false;
			_srcBones.Clear();
			_dstBones.Clear();
			_skipPositionCopy.Clear();
			_headRegionInstanceIds.Clear();
			_rendererPairs.Clear();
			_cosmeticMirrorCopies.Clear();
			TearDownHeldVisual(ref _leftHeldState);
			TearDownHeldVisual(ref _rightHeldState);
			TearDownSeatVisual();
			ClearProximityVisuals();
			DestroyProximityCircle();
			ClearRemoteRigClones();
			ClearLocalHolsterVisuals();
			_claimedRootIds.Clear();
			_cloneLeftHandTransform = null;
			_cloneRightHandTransform = null;
			_playerLeftHandTransform = null;
			_playerRightHandTransform = null;
			_pendingRebuildFrames = 0;
			_frozenFwd = null;
		}
	}
	public static class MenuSliderHelper
	{
		private struct SliderEntry
		{
			public string DisplayName;

			public FloatElement Element;

			public StringElement TypeElement;

			public float Increment;

			public float Min;

			public float Max;

			public Action<float> OnChanged;

			public bool WholeNumbers;
		}

		private static readonly List<SliderEntry> _sliders = new List<SliderEntry>();

		private static readonly HashSet<Page> _ourPages = new HashSet<Page>();

		private static readonly List<GameObject> _injectedArrows = new List<GameObject>();

		private static readonly List<GameObject> _hiddenRows = new List<GameObject>();

		private static readonly List<(RectTransform rect, Vector2 origSize)> _hiddenRowOffsets = new List<(RectTransform, Vector2)>();

		private static readonly List<(Transform button, Transform originalParent)> _reparentedButtons = new List<(Transform, Transform)>();

		private static readonly List<(RectTransform rect, Vector2 origPos, Vector3 origScale)> _movedOriginals = new List<(RectTransform, Vector2, Vector3)>();

		private static int _pendingArrowFrames;

		private static int _pendingArrowDelay;

		private static bool _eventHooked;

		public static FloatElement RegisterSliderWithType(Page page, string name, float value, float increment, float min, float max, Action<float> onChanged, bool wholeNumbers = false)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			HookEvent();
			_ourPages.Add(page);
			string fmt = (wholeNumbers ? "F0" : "F1");
			StringElement typeElem = null;
			FloatElement sliderElem = null;
			typeElem = page.CreateString("Type " + name, Color.white, value.ToString(fmt), (Action<string>)delegate(string val)
			{
				if (float.TryParse(val, out var result))
				{
					if (wholeNumbers && result != Mathf.Round(result))
					{
						if (sliderElem != null && typeElem != null)
						{
							typeElem.Value = sliderElem.Value.ToString(fmt);
						}
					}
					else
					{
						onChanged(result);
						if (sliderElem != null && !Mathf.Approximately(sliderElem.Value, result))
						{
							sliderElem.Value = result;
						}
					}
				}
			});
			sliderElem = page.CreateFloat(name, Color.yellow, value, increment, min, max, (Action<float>)delegate(float val)
			{
				if (wholeNumbers)
				{
					val = Mathf.Round(val);
				}
				onChanged(val);
				if (typeElem != null)
				{
					string text = val.ToString(fmt);
					if (typeElem.Value != text)
					{
						typeElem.Value = text;
					}
				}
			});
			_sliders.Add(new SliderEntry
			{
				DisplayName = name,
				Element = sliderElem,
				TypeElement = typeElem,
				Increment = increment,
				Min = min,
				Max = max,
				OnChanged = onChanged,
				WholeNumbers = wholeNumbers
			});
			return sliderElem;
		}

		public static void ResetSlider(string displayName, float value)
		{
			for (int i = 0; i < _sliders.Count; i++)
			{
				SliderEntry sliderEntry = _sliders[i];
				if (!(sliderEntry.DisplayName != displayName))
				{
					if (sliderEntry.Element != null)
					{
						sliderEntry.Element.Value = value;
					}
					if (sliderEntry.TypeElement != null)
					{
						sliderEntry.TypeElement.Value = value.ToString(sliderEntry.WholeNumbers ? "F0" : "F1");
					}
					sliderEntry.OnChanged?.Invoke(value);
					break;
				}
			}
		}

		private static void HookEvent()
		{
			if (!_eventHooked)
			{
				Menu.OnPageOpened += OnPageOpened;
				_eventHooked = true;
			}
		}

		private static void OnPageOpened(Page page)
		{
			CleanupInjectedArrows();
			if (_ourPages.Contains(page))
			{
				_pendingArrowDelay = 5;
				_pendingArrowFrames = 30;
			}
			else
			{
				_pendingArrowFrames = 0;
				_pendingArrowDelay = 0;
			}
		}

		public static void OnUpdate()
		{
			if (_pendingArrowFrames > 0)
			{
				if (_pendingArrowDelay > 0)
				{
					_pendingArrowDelay--;
					return;
				}
				_pendingArrowFrames--;
				InjectBigStepArrows();
			}
		}

		private static void InjectBigStepArrows()
		{
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0645: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: 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_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			GUIMenu instance = GUIMenu.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform activeView = instance.ActiveView;
			if ((Object)(object)activeView == (Object)null)
			{
				return;
			}
			int childCount = activeView.childCount;
			for (int i = 0; i < childCount; i++)
			{
				Transform child;
				try
				{
					child = activeView.GetChild(i);
				}
				catch
				{
					continue;
				}
				if ((Object)(object)child == (Object)null || !((Component)child).gameObject.activeSelf)
				{
					continue;
				}
				Transform val = child.Find("Decrement");
				Transform val2 = child.Find("Increment");
				Transform val3 = child.Find("Value");
				Transform val4 = child.Find("Name");
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || (Object)(object)child.Find("BigDecrement") != (Object)null)
				{
					continue;
				}
				TextMeshProUGUI component = ((Component)val4).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				string text = ((TMP_Text)component).text;
				SliderEntry? sliderEntry = null;
				foreach (SliderEntry slider2 in _sliders)
				{
					if (text == slider2.DisplayName)
					{
						sliderEntry = slider2;
						break;
					}
				}
				if (!sliderEntry.HasValue)
				{
					continue;
				}
				SliderEntry value = sliderEntry.Value;
				float bigStep = value.Increment * 10f;
				float min = value.Min;
				float max = value.Max;
				FloatElement slider = value.Element;
				Action<float> onChanged = value.OnChanged;
				RectTransform component2 = ((Component)val).GetComponent<RectTransform>();
				RectTransform component3 = ((Component)val2).GetComponent<RectTransform>();
				RectTransform component4 = ((Component)val3).GetComponent<RectTransform>();
				Vector2 anchoredPosition = component2.anchoredPosition;
				Vector2 anchoredPosition2 = component3.anchoredPosition;
				_movedOriginals.Add((component2, anchoredPosition, val.localScale));
				_movedOriginals.Add((component3, anchoredPosition2, val2.localScale));
				component2.anchoredPosition = new Vector2((anchoredPosition.x + component4.anchoredPosition.x) / 2f, anchoredPosition.y);
				val.localScale = Vector3.one * 0.75f;
				component3.anchoredPosition = new Vector2((component4.anchoredPosition.x + anchoredPosition2.x) / 2f, anchoredPosition2.y);
				val2.localScale = Vector3.one * 0.75f;
				GameObject val5 = Object.Instantiate<GameObject>(((Component)val).gameObject, child);
				((Object)val5).name = "BigDecrement";
				RectTransform component5 = val5.GetComponent<RectTransform>();
				component5.anchorMin = component2.anchorMin;
				component5.anchorMax = component2.anchorMax;
				component5.pivot = component2.pivot;
				component5.sizeDelta = component2.sizeDelta;
				component5.anchoredPosition = anchoredPosition;
				val5.transform.localScale = Vector3.one;
				Button component6 = val5.GetComponent<Button>();
				if ((Object)(object)component6 != (Object)null)
				{
					((UnityEventBase)component6.onClick).RemoveAllListeners();
					((UnityEvent)component6.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						float num3 = Mathf.Max(slider.Value - bigStep, min);
						slider.Value = num3;
						onChanged?.Invoke(num3);
					}));
				}
				_injectedArrows.Add(val5);
				GameObject val6 = Object.Instantiate<GameObject>(((Component)val2).gameObject, child);
				((Object)val6).name = "BigIncrement";
				RectTransform component7 = val6.GetComponent<RectTransform>();
				component7.anchorMin = component3.anchorMin;
				component7.anchorMax = component3.anchorMax;
				component7.pivot = component3.pivot;
				component7.sizeDelta = component3.sizeDelta;
				component7.anchoredPosition = anchoredPosition2;
				val6.transform.localScale = Vector3.one;
				Button component8 = val6.GetComponent<Button>();
				if ((Object)(object)component8 != (Object)null)
				{
					((UnityEventBase)component8.onClick).RemoveAllListeners();
					((UnityEvent)component8.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						float num2 = Mathf.Min(slider.Value + bigStep, max);
						slider.Value = num2;
						onChanged?.Invoke(num2);
					}));
				}
				_injectedArrows.Add(val6);
			}
			bool flag = false;
			for (int j = 0; j < childCount; j++)
			{
				Transform child2;
				try
				{
					child2 = activeView.GetChild(j);
				}
				catch
				{
					continue;
				}
				if ((Object)(object)child2 == (Object)null)
				{
					continue;
				}
				Transform val7 = child2.Find("Name");
				if ((Object)(object)val7 == (Object)null)
				{
					continue;
				}
				TextMeshProUGUI component9 = ((Component)val7).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component9 == (Object)null)
				{
					continue;
				}
				string text2 = ((TMP_Text)component9).text;
				if (!text2.StartsWith("Type ") || !((Component)child2).gameObject.activeSelf)
				{
					continue;
				}
				Transform val8 = child2.Find("ShowKeyboard");
				if ((Object)(object)val8 == (Object)null)
				{
					flag = true;
					continue;
				}
				string text3 = text2.Substring(5);
				bool flag2 = false;
				for (int k = 0; k < childCount; k++)
				{
					Transform child3;
					try
					{
						child3 = activeView.GetChild(k);
					}
					catch
					{
						continue;
					}
					if ((Object)(object)child3 == (Object)null || !((Component)child3).gameObject.activeSelf)
					{
						continue;
					}
					Transform val9 = child3.Find("Name");
					Transform val10 = child3.Find("Value");
					if ((Object)(object)val9 == (Object)null || (Object)(object)val10 == (Object)null)
					{
						continue;
					}
					TextMeshProUGUI component10 = ((Component)val9).GetComponent<TextMeshProUGUI>();
					if (!((Object)(object)component10 == (Object)null) && !(((TMP_Text)component10).text != text3))
					{
						_reparentedButtons.Add((val8, child2));
						val8.SetParent(val10, false);
						RectTransform component11 = ((Component)val8).GetComponent<RectTransform>();
						if ((Object)(object)component11 != (Object)null)
						{
							component11.anchorMin = Vector2.zero;
							component11.anchorMax = Vector2.one;
							component11.sizeDelta = Vector2.zero;
							component11.anchoredPosition = Vector2.zero;
						}
						Image component12 = ((Component)val8).GetComponent<Image>();
						if ((Object)(object)component12 != (Object)null)
						{
							((Graphic)component12).color = Color.clear;
						}
						for (int num = val8.childCount - 1; num >= 0; num--)
						{
							Object.Destroy((Object)(object)((Component)val8.GetChild(num)).gameObject);
						}
						RectTransform component13 = ((Component)child2).GetComponent<RectTransform>();
						if ((Object)(object)component13 != (Object)null)
						{
							_hiddenRowOffsets.Add((component13, component13.sizeDelta));
							component13.sizeDelta = new Vector2(component13.sizeDelta.x, 0f);
						}
						((Component)child2).gameObject.SetActive(false);
						_hiddenRows.Add(((Component)child2).gameObject);
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					flag = true;
				}
			}
			if (!flag)
			{
				_pendingArrowFrames = 0;
			}
		}

		private static void CleanupInjectedArrows()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_0193: Unknown result type (might be due to invalid IL or missing references)
			foreach (var (val, anchoredPosition, localScale) in _movedOriginals)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.anchoredPosition = anchoredPosition;
					((Component)val).transform.localScale = localScale;
				}
			}
			_movedOriginals.Clear();
			foreach (GameObject injectedArrow in _injectedArrows)
			{
				if ((Object)(object)injectedArrow != (Object)null)
				{
					Object.Destroy((Object)(object)injectedArrow);
				}
			}
			_injectedArrows.Clear();
			foreach (var (val2, val3) in _reparentedButtons)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)val3 != (Object)null)
				{
					val2.SetParent(val3, false);
				}
			}
			_reparentedButtons.Clear();
			foreach (GameObject hiddenRow in _hiddenRows)
			{
				if ((Object)(object)hiddenRow != (Object)null)
				{
					hiddenRow.SetActive(true);
				}
			}
			_hiddenRows.Clear();
			foreach (var (val4, sizeDelta) in _hiddenRowOffsets)
			{
				if ((Object)(object)val4 != (Object)null)
				{
					val4.sizeDelta = sizeDelta;
				}
			}
			_hiddenRowOffsets.Clear();
		}
	}
	public static class RadialToggle
	{
		private const string IconResourceName = "LocalMirrorMod.Resources.MirrorIcon.png";

		private static bool _wantNorth;

		private static bool _itemAdded;

		private static bool _iconApplied;

		private static Sprite _cachedSprite;

		public static void OnLevelLoaded()
		{
			_wantNorth = true;
			_itemAdded = false;
			_iconApplied = false;
			TryRegister();
		}

		public static void OnUpdate()
		{
			if (_wantNorth && (!_itemAdded || !_iconApplied))
			{
				TryRegister();
			}
		}

		private static void TryRegister()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PopUpMenuView instance = PopUpMenuView.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				PageView radialPageView = instance.radialPageView;
				if ((Object)(object)radialPageView == (Object)null)
				{
					return;
				}
				Page homePage = radialPageView.GetHomePage();
				if (((homePage != null) ? homePage.items : null) == null)
				{
					return;
				}
				Transform val = ((Component)instance).transform.Find("UI_POPUP/scaleOffset/CANVAS_RADIALUI");
				if ((Object)(object)val == (Object)null || val.childCount < 2)
				{
					return;
				}
				if (!_itemAdded)
				{
					for (int num = homePage.items.Count - 1; num >= 0; num--)
					{
						PageItem val2 = homePage.items[num];
						if (val2 != null && (int)val2.direction == 0)
						{
							homePage.items.RemoveAt(num);
						}
					}
					PageItem val3 = new PageItem("Mirror", (Directions)0, Action.op_Implicit((Action)OnNorthPressed));
					homePage.items.Add(val3);
					radialPageView.SetHomePage(homePage);
					_itemAdded = true;
				}
				if (_iconApplied)
				{
					return;
				}
				Transform child = val.GetChild(1);
				if (!((Object)(object)child != (Object)null) || !(((Object)child).name == "img_sprite"))
				{
					return;
				}
				Image component = ((Component)child).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					if ((Object)(object)_cachedSprite == (Object)null || (Object)(object)_cachedSprite == (Object)null)
					{
						_cachedSprite = LoadIconFromEmbeddedResource();
					}
					if ((Object)(object)_cachedSprite != (Object)null)
					{
						component.sprite = _cachedSprite;
						_iconApplied = true;
					}
					else
					{
						MelonLogger.Warning("[LocalMirror.Radial] embedded icon resource missing or unreadable.");
						_iconApplied = true;
					}
				}
			}
			catch (Exception value)
			{
				MelonLogger.Warning($"[LocalMirror.Radial] TryRegister error: {value}");
			}
		}

		private static void OnNorthPressed()
		{
			try
			{
				LocalMirror.Toggle();
				try
				{
					PopUpMenuView instance = PopUpMenuView.instance;
					if (instance != null)
					{
						instance.Deactivate();
					}
				}
				catch
				{
				}
			}
			catch (Exception value)
			{
				MelonLogger.Warning($"[LocalMirror.Radial] OnNorthPressed error: {value}");
			}
		}

		private static Sprite LoadIconFromEmbeddedResource()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_00c2: 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)
			try
			{
				using Stream stream = typeof(RadialToggle).Assembly.GetManifestResourceStream("LocalMirrorMod.Resources.MirrorIcon.png");
				if (stream == null)
				{
					MelonLogger.Warning("[LocalMirror.Radial] resource 'LocalMirrorMod.Resources.MirrorIcon.png' not found in assembly.");
					return null;
				}
				byte[] array = new byte[stream.Length];
				int num;
				for (int i = 0; i < array.Length; i += num)
				{
					num = stream.Read(array, i, array.Length - i);
					if (num <= 0)
					{
						break;
					}
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array)))
				{
					MelonLogger.Warning("[LocalMirror.Radial] LoadImage failed on embedded icon resource.");
					return null;
				}
				((Object)val).name = "LocalMirror_MirrorIcon_tex";
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)val);
				Rect val2 = default(Rect);
				((Rect)(ref val2))..ctor(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height);
				Sprite obj = Sprite.Create(val, val2, new Vector2(0.5f, 0.5f));
				((Object)obj).name = "LocalMirror_MirrorIcon";
				((Object)obj).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)obj);
				return obj;
			}
			catch (Exception value)
			{
				MelonLogger.Warning($"[LocalMirror.Radial] LoadIconFromEmbeddedResource threw: {value}");
				return null;
			}
		}
	}
}