using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AC130;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using HarmonyLib;
using Il2CppInterop.Common;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.AI;
using Il2CppSLZ.Marrow.Combat;
using Il2CppSLZ.Marrow.Warehouse;
using Il2CppSLZ.VRMK;
using Il2CppSystem;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using TimelineClones;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.XR;
using Wiggles;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: MelonInfo(typeof(WigglesBW), "Timeline Colliders", "1.7.0", "adama", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: MelonOptionalDependencies(new string[] { "Timeline" })]
[assembly: HarmonyDontPatchAll]
[assembly: InternalsVisibleTo("TimelineColliders.Timeline")]
[assembly: SecurityPermission((SecurityAction)8, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.0.0")]
[module: UnverifiableCode]
namespace AC130
{
	internal static class PixelFont
	{
		internal const int GlyphW = 5;

		internal const int GlyphH = 7;

		private static readonly Dictionary<char, string> Glyphs = new Dictionary<char, string>
		{
			['A'] = "01110100011000111111100011000110001",
			['B'] = "11110100011000111110100011000111110",
			['C'] = "01110100011000010000100001000101110",
			['D'] = "11110100011000110001100011000111110",
			['E'] = "11111100001000011110100001000011111",
			['F'] = "11111100001000011110100001000010000",
			['G'] = "01110100011000010111100011000101111",
			['H'] = "10001100011000111111100011000110001",
			['I'] = "01110001000010000100001000010001110",
			['J'] = "00111000100001000010000101001001100",
			['K'] = "10001100101010011000101001001010001",
			['L'] = "10000100001000010000100001000011111",
			['M'] = "10001110111010110101100011000110001",
			['N'] = "10001100011100110101100111000110001",
			['O'] = "01110100011000110001100011000101110",
			['P'] = "11110100011000111110100001000010000",
			['Q'] = "01110100011000110001101011001001101",
			['R'] = "11110100011000111110101001001010001",
			['S'] = "01111100001000001110000010000111110",
			['T'] = "11111001000010000100001000010000100",
			['U'] = "10001100011000110001100011000101110",
			['V'] = "10001100011000110001100010101000100",
			['W'] = "10001100011000110101101011010101010",
			['X'] = "10001100010101000100010101000110001",
			['Y'] = "10001100010101000100001000010000100",
			['Z'] = "11111000010001000100010001000011111",
			['0'] = "01110100011001110101110011000101110",
			['1'] = "00100011000010000100001000010001110",
			['2'] = "01110100010000100010001000100011111",
			['3'] = "11111000100010000010000011000101110",
			['4'] = "00010001100101010010111110001000010",
			['5'] = "11111100001111000001000011000101110",
			['6'] = "00110010001000011110100011000101110",
			['7'] = "11111000010001000100010000100001000",
			['8'] = "01110100011000101110100011000101110",
			['9'] = "01110100011000101111000010001001100",
			[':'] = "00000011000110000000011000110000000",
			['.'] = "00000000000000000000000000110001100",
			['%'] = "11000110010001000100010001001100011",
			['/'] = "00000000010001000100010001000000000",
			['-'] = "00000000000000011111000000000000000",
			['+'] = "00000001000010011111001000010000000",
			['!'] = "00100001000010000100001000000000100",
			['>'] = "01000001000001000001000100010001000",
			['<'] = "00010001000100010000010000010000010",
			['['] = "01110010000100001000010000100001110",
			[']'] = "01110000100001000010000100001001110",
			['#'] = "01010010101111101010111110101001010",
			['='] = "00000000001111100000111110000000000",
			['*'] = "00000001001010101110101010010000000",
			['?'] = "01110100010000100010001000000000100",
			[','] = "00000000000000000000011000010001000",
			['_'] = "00000000000000000000000000000011111"
		};

		internal static int Measure(string text, int scale)
		{
			return text.Length * 6 * scale - scale;
		}

		internal static void Draw(Color32[] buf, int bw, int bh, string text, int x, int y, int scale, Color32 color, bool outline = true)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (outline)
			{
				Color32 color2 = default(Color32);
				((Color32)(ref color2))..ctor((byte)0, (byte)0, (byte)0, (byte)255);
				DrawRaw(buf, bw, bh, text, x + scale, y + scale, scale, color2);
			}
			DrawRaw(buf, bw, bh, text, x, y, scale, color);
		}

		internal static void DrawCentered(Color32[] buf, int bw, int bh, string text, int cy, int scale, Color32 color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			Draw(buf, bw, bh, text, (bw - Measure(text, scale)) / 2, cy, scale, color);
		}

		private static void DrawRaw(Color32[] buf, int bw, int bh, string text, int x, int y, int scale, Color32 color)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = x;
			string text2 = default(string);
			for (int i = 0; i < text.Length; i++)
			{
				char c = char.ToUpperInvariant(text[i]);
				if (Glyphs.TryGetValue(c, ref text2))
				{
					for (int j = 0; j < 7; j++)
					{
						for (int k = 0; k < 5; k++)
						{
							if (text2[j * 5 + k] == '1')
							{
								FillRect(buf, bw, bh, num + k * scale, y + j * scale, scale, scale, color);
							}
						}
					}
				}
				num += 6 * scale;
			}
		}

		internal static void FillRect(Color32[] buf, int bw, int bh, int x, int y, int w, int h, Color32 color)
		{
			//IL_003a: 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)
			int num = Mathf.Max(0, x);
			int num2 = Mathf.Max(0, y);
			int num3 = Mathf.Min(bw, x + w);
			int num4 = Mathf.Min(bh, y + h);
			for (int i = num2; i < num4; i++)
			{
				int num5 = i * bw;
				for (int j = num; j < num3; j++)
				{
					buf[num5 + j] = color;
				}
			}
		}

		internal static void Rect(Color32[] buf, int bw, int bh, int x, int y, int w, int h, Color32 color)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			FillRect(buf, bw, bh, x, y, w, 1, color);
			FillRect(buf, bw, bh, x, y + h - 1, w, 1, color);
			FillRect(buf, bw, bh, x, y, 1, h, color);
			FillRect(buf, bw, bh, x + w - 1, y, 1, h, color);
		}
	}
}
namespace Wiggles
{
	internal static class CrashGuard
	{
		private static MelonPreferences_Category _prefs;

		internal static MelonPreferences_Entry<bool> SafeMode;

		private static MelonPreferences_Entry<int> Crashes;

		private static MelonPreferences_Entry<string> TurnedOff;

		private static MelonPreferences_Entry<string> LastVersion;

		private static string _marker;

		private static bool _markedGood;

		private static float _inLevelFor;

		private static readonly HashSet<string> _off = new HashSet<string>();

		private static string _playMarker;

		private static string _lastDoing;

		private static string _level;

		private static float _nextDoing;

		private static readonly List<ValueTuple<string, Func<bool>>> _doing = new List<ValueTuple<string, Func<bool>>>();

		internal static bool AnyOff => _off.Count > 0;

		internal static void Track(string what, Func<bool> on)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_doing.Add(new ValueTuple<string, Func<bool>>(what, on));
		}

		internal static void Start(string version)
		{
			_prefs = MelonPreferences.CreateCategory("WigglesBW");
			SafeMode = _prefs.CreateEntry<bool>("SafeMode", false, "Safe mode: all Timeline Colliders features off (turns on by itself after 2 crashes while loading)", (string)null, false, false, (ValueValidator)null, (string)null);
			Crashes = _prefs.CreateEntry<int>("CrashesWhileLoading", 0, "Launches in a row that crashed while loading (set by Timeline Colliders)", (string)null, false, false, (ValueValidator)null, (string)null);
			TurnedOff = _prefs.CreateEntry<string>("TurnedOffAfterCrash", "", "Parts turned off because the game crashed while they started (set by Timeline Colliders)", (string)null, false, false, (ValueValidator)null, (string)null);
			LastVersion = _prefs.CreateEntry<string>("LastVersion", "", "Version that ran last (set by Timeline Colliders)", (string)null, false, false, (ValueValidator)null, (string)null);
			if (LastVersion.Value != version)
			{
				if (SafeMode.Value || Crashes.Value != 0 || TurnedOff.Value.Length > 0)
				{
					WigglesBW.Log.Msg("Updated to " + version + ": safe mode and crash history cleared.");
				}
				SafeMode.Value = false;
				Crashes.Value = 0;
				TurnedOff.Value = "";
				LastVersion.Value = version;
			}
			SafeMode.Value = false;
			TurnedOff.Value = "";
			string text = null;
			try
			{
				string text2 = Path.Combine(MelonEnvironment.UserDataDirectory, "WigglesBW");
				Directory.CreateDirectory(text2);
				_marker = Path.Combine(text2, "loading.marker");
				_playMarker = Path.Combine(text2, "playing.marker");
				if (File.Exists(_playMarker))
				{
					string[] array = File.ReadAllLines(_playMarker);
					string text3 = ((array.Length > 1) ? array[1].Trim() : "");
					string text4 = ((array.Length != 0) ? array[0].Trim() : "");
					WigglesBW.Log.Warning("The last session ended without quitting normally (crash or closed from the headset menu) at " + text4 + ", while: " + ((text3.Length > 0) ? text3 : "playing"));
					Diagnostics.Report("Last Session", "The game closed without quitting normally last time (a crash, or closed from the headset menu) while: " + ((text3.Length > 0) ? text3 : "playing") + ". If it crashed, send the MelonLoader log of that session (MelonLoader/Logs) to the mod author.");
					File.Delete(_playMarker);
				}
				if (File.Exists(_marker))
				{
					string[] array2 = File.ReadAllLines(_marker);
					text = ((array2.Length > 1) ? array2[1].Trim() : "");
					WigglesBW.Log.Warning("The last launch didn't finish loading (crash?). It was at: " + (string.IsNullOrEmpty(text) ? "starting" : text));
				}
			}
			catch (global::System.Exception ex)
			{
				WigglesBW.Log.Warning("Crash protection unavailable: " + ex.Message);
			}
			string text5 = Blame(text);
			if (text5 != null)
			{
				Diagnostics.Report("Crash", $"The game crashed last time while {"Timeline Colliders"} was starting \"{Friendly(text5)}\". Please send the MelonLoader log to the mod author.");
			}
			else if (text != null)
			{
				MelonPreferences_Entry<int> crashes = Crashes;
				int value = crashes.Value;
				crashes.Value = value + 1;
				Diagnostics.Report("Crash", "The last launch crashed while loading. If it keeps happening, send the MelonLoader log to the mod author.");
			}
			if (_off.Count > 0)
			{
				WigglesBW.Log.Warning("Turned off after a crash: " + string.Join(", ", Enumerable.Select<string, string>((global::System.Collections.Generic.IEnumerable<string>)_off, (Func<string, string>)Friendly)));
			}
			Stage("starting");
			Save();
		}

		private static string Blame(string stage)
		{
			if (string.IsNullOrEmpty(stage))
			{
				return null;
			}
			if (stage.StartsWith("module:"))
			{
				return stage;
			}
			if (stage.StartsWith("hook:"))
			{
				return stage;
			}
			if (stage.StartsWith("after hook:"))
			{
				return "hook:" + stage.Substring("after hook:".Length);
			}
			return null;
		}

		private static string Friendly(string id)
		{
			if (!id.StartsWith("module:"))
			{
				if (!id.StartsWith("hook:"))
				{
					return id;
				}
				return "game hook " + id.Substring(5);
			}
			return id.Substring(7);
		}

		internal static bool IsOff(string id)
		{
			return _off.Contains(id);
		}

		internal static void Stage(string what)
		{
			if (_markedGood || _marker == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(_marker, global::System.DateTime.Now.ToString("o") + "\n" + what + "\n");
			}
			catch
			{
			}
		}

		internal static void LateHookStart(string id)
		{
			if (_marker == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(_marker, global::System.DateTime.Now.ToString("o") + "\nhook:" + id + "\n");
			}
			catch
			{
			}
		}

		internal static void LateHookDone()
		{
			if (!_markedGood)
			{
				Stage("playing");
				return;
			}
			try
			{
				if (_marker != null && File.Exists(_marker))
				{
					File.Delete(_marker);
				}
			}
			catch
			{
			}
		}

		internal static void NoteLevel(string what)
		{
			_level = what;
			_lastDoing = null;
			if (_playMarker == null)
			{
				return;
			}
			try
			{
				File.WriteAllText(_playMarker, global::System.DateTime.Now.ToString("o") + "\n" + what + "\n");
			}
			catch
			{
			}
		}

		internal static void Update()
		{
			if (_markedGood)
			{
				UpdateDoing();
				return;
			}
			if ((Object)(object)Player.Head == (Object)null)
			{
				_inLevelFor = 0f;
				return;
			}
			_inLevelFor += Time.unscaledDeltaTime;
			if (!(_inLevelFor < 20f) && !Patches.Pending)
			{
				MarkGood();
			}
		}

		internal static void CleanExit()
		{
			MarkGood();
			try
			{
				if (_playMarker != null && File.Exists(_playMarker))
				{
					File.Delete(_playMarker);
				}
			}
			catch
			{
			}
			_lastDoing = null;
		}

		private static void UpdateDoing()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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)
			if (_playMarker == null || Time.realtimeSinceStartup < _nextDoing)
			{
				return;
			}
			_nextDoing = Time.realtimeSinceStartup + 3f;
			List<string> val = new List<string>();
			Enumerator<ValueTuple<string, Func<bool>>> enumerator = _doing.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ValueTuple<string, Func<bool>> current = enumerator.Current;
					string item = current.Item1;
					Func<bool> item2 = current.Item2;
					try
					{
						if (item2.Invoke())
						{
							val.Add(item);
						}
					}
					catch
					{
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			string text = ((val.Count > 0) ? string.Join(", ", (global::System.Collections.Generic.IEnumerable<string>)val) : "playing");
			if (_level != null)
			{
				text = text + " (" + _level + ")";
			}
			if (text == _lastDoing)
			{
				return;
			}
			_lastDoing = text;
			try
			{
				File.WriteAllText(_playMarker, global::System.DateTime.Now.ToString("o") + "\n" + text + "\n");
			}
			catch
			{
			}
		}

		private static void MarkGood()
		{
			if (_markedGood)
			{
				return;
			}
			_markedGood = true;
			try
			{
				if (_marker != null && File.Exists(_marker))
				{
					File.Delete(_marker);
				}
			}
			catch
			{
			}
			if (Crashes != null && Crashes.Value != 0)
			{
				Crashes.Value = 0;
				Save();
			}
		}

		internal static void SetSafeMode(bool on)
		{
			SafeMode.Value = on;
			if (!on)
			{
				Crashes.Value = 0;
			}
			Save();
		}

		internal static void TurnEverythingBackOn()
		{
			_off.Clear();
			TurnedOff.Value = "";
			SafeMode.Value = false;
			Crashes.Value = 0;
			Save();
		}

		private static void Save()
		{
			try
			{
				_prefs.SaveToFile(false);
			}
			catch
			{
			}
		}
	}
	internal static class CrateAsset
	{
		internal static bool Load(string barcode, Action<GameObject> done)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			AssetWarehouse instance = AssetWarehouse.Instance;
			Crate val = default(Crate);
			if (instance == null || !instance.TryGetCrate(new Barcode(barcode), ref val) || (Object)(object)val == (Object)null)
			{
				return false;
			}
			SpawnableCrate val2 = ((Il2CppObjectBase)val).TryCast<SpawnableCrate>();
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			Action<GameObject> val3 = delegate(GameObject go)
			{
				try
				{
					done.Invoke(go);
				}
				catch (global::System.Exception ex)
				{
					WigglesBW.Log.Warning("Loading " + barcode + " failed: " + ex.Message);
				}
			};
			((CrateT<GameObject>)(object)val2).LoadAsset(Action<GameObject>.op_Implicit(val3));
			return true;
		}
	}
	internal static class Diagnostics
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<MelonBase, bool> <>9__12_0;

			public static Func<ValueTuple<string, string>, bool> <>9__14_0;

			public static Func<ValueTuple<string, string>, string> <>9__15_0;

			public static Action <>9__21_0;

			public static Action <>9__21_2;

			public static Action <>9__21_1;

			internal bool <CheckStartup>b__12_0(MelonBase m)
			{
				return m.Info.Name == "BoneLib";
			}

			internal bool <OnLevelLoaded>b__14_0(ValueTuple<string, string> p)
			{
				//IL_0000: 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)
				return Severe(p.Item1, p.Item2);
			}

			internal string <Update>b__15_0(ValueTuple<string, string> p)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return p.Item2;
			}

			internal void <RefreshPage>b__21_0()
			{
			}

			internal void <RefreshPage>b__21_2()
			{
			}

			internal void <RefreshPage>b__21_1()
			{
				_shownThisLevel = false;
				_pendingShow = true;
			}
		}

		[CompilerGenerated]
		private sealed class <Wrap>d__19 : global::System.Collections.Generic.IEnumerable<string>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<string>, global::System.IDisposable, global::System.Collections.IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string text;

			public string <>3__text;

			private int width;

			public int <>3__width;

			private string[] <>7__wrap1;

			private int <>7__wrap2;

			private string <w>5__4;

			string global::System.Collections.Generic.IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
			}

			private bool MoveNext()
			{
				string text;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string[] array = this.text.Split(' ', (StringSplitOptions)0);
					text = "";
					<>7__wrap1 = array;
					<>7__wrap2 = 0;
					goto IL_00d6;
				}
				case 1:
					<>1__state = -1;
					text = "";
					goto IL_009f;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00d6:
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						<w>5__4 = <>7__wrap1[<>7__wrap2];
						if (text.Length + <w>5__4.Length + 1 > width && text.Length > 0)
						{
							<>2__current = text;
							<>1__state = 1;
							return true;
						}
						goto IL_009f;
					}
					<>7__wrap1 = null;
					if (text.Length > 0)
					{
						<>2__current = text;
						<>1__state = 2;
						return true;
					}
					break;
					IL_009f:
					text = ((text.Length == 0) ? <w>5__4 : (text + " " + <w>5__4));
					<w>5__4 = null;
					<>7__wrap2++;
					goto IL_00d6;
				}
				return false;
			}

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

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<string> global::System.Collections.Generic.IEnumerable<string>.GetEnumerator()
			{
				<Wrap>d__19 <Wrap>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<Wrap>d__ = this;
				}
				else
				{
					<Wrap>d__ = new <Wrap>d__19(0);
				}
				<Wrap>d__.text = <>3__text;
				<Wrap>d__.width = <>3__width;
				return <Wrap>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<string>)this).GetEnumerator();
			}
		}

		internal static readonly Version MinBoneLib = new Version(3, 2, 0);

		private static readonly List<ValueTuple<string, string>> _problems = new List<ValueTuple<string, string>>();

		private static readonly HashSet<string> _seen = new HashSet<string>();

		private static bool _shownThisLevel;

		private static bool _pendingShow;

		private static float _hideAt;

		private static GameObject _panel;

		private static Texture2D _tex;

		private static Page _page;

		private const int W = 640;

		private const int H = 300;

		internal static int Count => _problems.Count;

		internal static void Report(string where, string what)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			string text = where + "|" + what;
			if (_seen.Add(text))
			{
				_problems.Add(new ValueTuple<string, string>(where, what));
				Instance log = WigglesBW.Log;
				if (log != null)
				{
					log.Warning("PROBLEM [" + where + "] " + what);
				}
				if (Severe(where, what))
				{
					_pendingShow = true;
				}
				RefreshPage();
			}
		}

		internal static void CheckStartup(MelonMod self)
		{
			try
			{
				MelonBase val = Enumerable.FirstOrDefault<MelonBase>((global::System.Collections.Generic.IEnumerable<MelonBase>)MelonBase.RegisteredMelons, (Func<MelonBase, bool>)((MelonBase m) => m.Info.Name == "BoneLib"));
				Version val2 = default(Version);
				if (val != null && Version.TryParse(val.Info.Version.Split('-', (StringSplitOptions)0)[0], ref val2) && val2 < MinBoneLib)
				{
					Report("BoneLib", $"BoneLib {val.Info.Version} is too old. Install BoneLib {MinBoneLib}+ (bonelib-BoneLib on Thunderstore).");
				}
			}
			catch
			{
			}
		}

		private static bool Severe(string where, string what)
		{
			if (!(where == "Safe Mode"))
			{
				return what.IndexOf("stays off", (StringComparison)5) >= 0;
			}
			return true;
		}

		internal static void OnLevelLoaded()
		{
			_shownThisLevel = false;
			if (Enumerable.Any<ValueTuple<string, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<string, string>>)_problems, (Func<ValueTuple<string, string>, bool>)((ValueTuple<string, string> p) => Severe(p.Item1, p.Item2))))
			{
				_pendingShow = true;
			}
		}

		internal static void Update()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			if ((Object)(object)_panel != (Object)null)
			{
				Transform head = Player.Head;
				if ((Object)(object)head == (Object)null || Time.realtimeSinceStartup > _hideAt)
				{
					Object.Destroy((Object)(object)_panel);
					_panel = null;
				}
				else
				{
					Vector3 val = Vector3.ProjectOnPlane(head.forward, Vector3.up);
					Vector3 val2 = ((Vector3)(ref val)).normalized;
					if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
					{
						val2 = Vector3.forward;
					}
					Vector3 val3 = head.position + val2 * 1.3f;
					float num = Mathf.Min(1f, 4f * Time.unscaledDeltaTime);
					_panel.transform.position = Vector3.Lerp(_panel.transform.position, val3, num);
					_panel.transform.rotation = Quaternion.Slerp(_panel.transform.rotation, Quaternion.LookRotation(val2), num);
				}
			}
			if (!_pendingShow || _shownThisLevel || _problems.Count == 0)
			{
				return;
			}
			Transform head2 = Player.Head;
			if ((Object)(object)head2 == (Object)null)
			{
				return;
			}
			_pendingShow = false;
			_shownThisLevel = true;
			try
			{
				ShowPanel(head2);
			}
			catch (global::System.Exception ex)
			{
				Instance log = WigglesBW.Log;
				if (log != null)
				{
					log.Warning("Problem panel failed: " + ex.Message);
				}
			}
			try
			{
				Notifier.Send(new Notification
				{
					Title = NotificationText.op_Implicit("Timeline Colliders: problem found"),
					Message = NotificationText.op_Implicit(string.Join("\n", Enumerable.Select<ValueTuple<string, string>, string>(Enumerable.Take<ValueTuple<string, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<string, string>>)_problems, 3), (Func<ValueTuple<string, string>, string>)((ValueTuple<string, string> p) => p.Item2)))),
					PopupLength = 10f,
					ShowTitleOnPopup = true
				});
			}
			catch
			{
			}
		}

		private static void ShowPanel(Transform head)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_01d2: 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_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: 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_024c: Expected O, but got Unknown
			//IL_02cc: 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_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: 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_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Expected O, but got Unknown
			Color32[] array = (Color32[])(object)new Color32[192000];
			Color32 val = default(Color32);
			((Color32)(ref val))..ctor((byte)20, (byte)6, (byte)6, (byte)235);
			Color32 color = default(Color32);
			((Color32)(ref color))..ctor((byte)255, (byte)70, (byte)60, (byte)255);
			Color32 color2 = default(Color32);
			((Color32)(ref color2))..ctor((byte)240, (byte)240, (byte)240, (byte)255);
			Color32 color3 = default(Color32);
			((Color32)(ref color3))..ctor((byte)170, (byte)170, (byte)170, (byte)255);
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = val;
			}
			PixelFont.Rect(array, 640, 300, 0, 0, 640, 300, color);
			PixelFont.Rect(array, 640, 300, 1, 1, 638, 298, color);
			PixelFont.DrawCentered(array, 640, 300, "Timeline Colliders".ToUpperInvariant() + " - PROBLEM FOUND", 10, 3, color);
			int num = 44;
			Enumerator<ValueTuple<string, string>> enumerator = _problems.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ValueTuple<string, string> current = enumerator.Current;
					string item = current.Item1;
					string item2 = current.Item2;
					global::System.Collections.Generic.IEnumerator<string> enumerator2 = Wrap("[" + item.ToUpperInvariant() + "] " + item2.ToUpperInvariant(), 50).GetEnumerator();
					try
					{
						while (((global::System.Collections.IEnumerator)enumerator2).MoveNext())
						{
							string current2 = enumerator2.Current;
							if (num > 270)
							{
								break;
							}
							PixelFont.Draw(array, 640, 300, current2, 12, num, 2, color2);
							num += 18;
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator2)?.Dispose();
					}
					num += 6;
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			PixelFont.DrawCentered(array, 640, 300, "FULL LIST: BONEMENU > " + "Timeline Colliders".ToUpperInvariant() + " > PROBLEMS", 282, 1, color3);
			Color32[] array2 = (Color32[])(object)new Color32[array.Length];
			for (int j = 0; j < 300; j++)
			{
				global::System.Array.Copy((global::System.Array)array, j * 640, (global::System.Array)array2, (299 - j) * 640, 640);
			}
			if ((Object)(object)_tex == (Object)null)
			{
				_tex = new Texture2D(640, 300, (TextureFormat)4, false)
				{
					filterMode = (FilterMode)0,
					hideFlags = (HideFlags)32
				};
			}
			_tex.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(array2));
			_tex.Apply(false, false);
			if ((Object)(object)_panel != (Object)null)
			{
				Object.Destroy((Object)(object)_panel);
			}
			_panel = GameObject.CreatePrimitive((PrimitiveType)5);
			((Object)_panel).name = "WigglesBW_Problems";
			Object.Destroy((Object)(object)_panel.GetComponent<Collider>());
			Object.DontDestroyOnLoad((Object)(object)_panel);
			_panel.transform.localScale = new Vector3(1.2f, 0.5625f, 1f);
			Vector3 val2 = Vector3.ProjectOnPlane(head.forward, Vector3.up);
			Vector3 val3 = ((Vector3)(ref val2)).normalized;
			if (((Vector3)(ref val3)).sqrMagnitude < 0.01f)
			{
				val3 = Vector3.forward;
			}
			_panel.transform.SetPositionAndRotation(head.position + val3 * 1.3f, Quaternion.LookRotation(val3));
			Material val4 = new Material(Shader.Find("UI/Default") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Universal Render Pipeline/Unlit"))
			{
				renderQueue = 4000
			};
			if (val4.HasProperty("_MainTex"))
			{
				val4.SetTexture("_MainTex", (Texture)(object)_tex);
			}
			if (val4.HasProperty("_BaseMap"))
			{
				val4.SetTexture("_BaseMap", (Texture)(object)_tex);
			}
			MeshRenderer component = _panel.GetComponent<MeshRenderer>();
			((Renderer)component).sharedMaterial = val4;
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			_hideAt = Time.realtimeSinceStartup + 20f;
		}

		[IteratorStateMachine(typeof(<Wrap>d__19))]
		private static global::System.Collections.Generic.IEnumerable<string> Wrap(string text, int width)
		{
			string[] array = text.Split(' ', (StringSplitOptions)0);
			string text2 = "";
			string[] array2 = array;
			foreach (string w in array2)
			{
				if (text2.Length + w.Length + 1 > width && text2.Length > 0)
				{
					yield return text2;
					text2 = "";
				}
				text2 = ((text2.Length == 0) ? w : (text2 + " " + w));
			}
			if (text2.Length > 0)
			{
				yield return text2;
			}
		}

		internal static void CreatePage(Page parent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_page = parent.CreatePage("Problems", new Color(1f, 0.3f, 0.3f), 0, true);
				RefreshPage();
			}
			catch
			{
			}
		}

		private static void RefreshPage()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			if (_page == null)
			{
				return;
			}
			try
			{
				_page.RemoveAll();
				if (_problems.Count == 0)
				{
					Page page = _page;
					Color green = Color.green;
					object obj = <>c.<>9__21_0;
					if (obj == null)
					{
						Action val = delegate
						{
						};
						<>c.<>9__21_0 = val;
						obj = (object)val;
					}
					page.CreateFunction("No problems found", green, (Action)obj);
					return;
				}
				Enumerator<ValueTuple<string, string>> enumerator = _problems.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						ValueTuple<string, string> current = enumerator.Current;
						string item = current.Item1;
						string item2 = current.Item2;
						Page page2 = _page;
						string text = "[" + item + "] " + item2;
						Color val2 = new Color(1f, 0.6f, 0.6f);
						object obj2 = <>c.<>9__21_2;
						if (obj2 == null)
						{
							Action val3 = delegate
							{
							};
							<>c.<>9__21_2 = val3;
							obj2 = (object)val3;
						}
						page2.CreateFunction(text, val2, (Action)obj2);
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				Page page3 = _page;
				Color yellow = Color.yellow;
				object obj3 = <>c.<>9__21_1;
				if (obj3 == null)
				{
					Action val4 = delegate
					{
						_shownThisLevel = false;
						_pendingShow = true;
					};
					<>c.<>9__21_1 = val4;
					obj3 = (object)val4;
				}
				page3.CreateFunction("Show problem panel again", yellow, (Action)obj3);
			}
			catch
			{
			}
		}
	}
	internal static class Patches
	{
		private static Harmony _harmony;

		private const float FirstWait = 8f;

		private const float MaxCalmWait = 40f;

		private const float HitchSeconds = 0.12f;

		private static readonly List<ValueTuple<string, Action<Harmony>>> _queue = new List<ValueTuple<string, Action<Harmony>>>();

		private static readonly List<ValueTuple<string, Func<bool>, Action<Harmony>>> _later = new List<ValueTuple<string, Func<bool>, Action<Harmony>>>();

		private static readonly List<Func<bool>> _fireWanted = new List<Func<bool>>();

		private static readonly List<Func<bool>> _walkBlockers = new List<Func<bool>>();

		private static readonly List<Func<Gun, bool>> _fireFilters = new List<Func<Gun, bool>>();

		private static bool _walkQueued;

		private static bool _fireQueued;

		private static bool _crouchQueued;

		private static readonly List<Func<bool>> _crouchFreezers = new List<Func<bool>>();

		private static float _nextAt = -1f;

		private static float _inLevelSince;

		internal static bool Pending => _queue.Count > 0;

		internal static void Init(Harmony harmony)
		{
			_harmony = harmony;
		}

		internal static void Add(string id, Action<Harmony> apply)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (CrashGuard.IsOff("hook:" + id))
			{
				WigglesBW.Log.Warning("Hook \"" + id + "\" is off (it crashed the game before).");
			}
			else
			{
				_queue.Add(new ValueTuple<string, Action<Harmony>>(id, apply));
			}
		}

		internal static void AddWhen(string id, Func<bool> when, Action<Harmony> apply)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (CrashGuard.IsOff("hook:" + id))
			{
				WigglesBW.Log.Warning("Hook \"" + id + "\" is off (it crashed the game before).");
			}
			else
			{
				_later.Add(new ValueTuple<string, Func<bool>, Action<Harmony>>(id, when, apply));
			}
		}

		private static bool Any(List<Func<bool>> list)
		{
			for (int i = 0; i < list.Count; i++)
			{
				try
				{
					if (list[i].Invoke())
					{
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		internal static void BlockWalkingWhile(Func<bool> blockWhen)
		{
			_walkBlockers.Add(blockWhen);
			if (!_walkQueued)
			{
				_walkQueued = true;
				AddWhen("walk-block", () => Any(_walkBlockers), delegate(Harmony h)
				{
					PatchPrefix(h, (MethodBase)(object)AccessTools.Method(typeof(ControllerRig), "GetPrimaryAxis", (global::System.Type[])null, (global::System.Type[])null), "WalkPrefix");
				});
			}
		}

		internal static void FreezeCrouchInputWhile(Func<bool> freezeWhen)
		{
			_crouchFreezers.Add(freezeWhen);
			if (!_crouchQueued)
			{
				_crouchQueued = true;
				AddWhen("crouch-input", () => Any(_crouchFreezers), delegate(Harmony h)
				{
					PatchPrefix(h, (MethodBase)(object)AccessTools.Method(typeof(RemapRig), "CrouchHold", (global::System.Type[])null, (global::System.Type[])null), "CrouchHoldPrefix");
				});
			}
		}

		private static void CrouchHoldPrefix(ref float crouchRate, ref bool crouchInput)
		{
			for (int i = 0; i < _crouchFreezers.Count; i++)
			{
				bool flag = false;
				try
				{
					flag = _crouchFreezers[i].Invoke();
				}
				catch
				{
				}
				if (flag)
				{
					crouchRate = 0f;
					crouchInput = false;
					break;
				}
			}
		}

		internal static void BeforeGunFire(Func<Gun, bool> allow, Func<bool> neededWhen)
		{
			_fireFilters.Add(allow);
			_fireWanted.Add(neededWhen);
			if (!_fireQueued)
			{
				_fireQueued = true;
				AddWhen("gun-fire", () => Any(_fireWanted), delegate(Harmony h)
				{
					PatchPrefix(h, (MethodBase)(object)AccessTools.Method(typeof(Gun), "Fire", (global::System.Type[])null, (global::System.Type[])null), "FirePrefix");
				});
			}
		}

		internal static void Prefix(string id, MethodBase target, global::System.Type holder, string method, Func<bool> when = null)
		{
			Action<Harmony> apply = delegate(Harmony h)
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				if (target != (MethodBase)null && !Refused(target))
				{
					h.Patch(target, new HarmonyMethod(holder.GetMethod(method, (BindingFlags)56)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			};
			if (when != null)
			{
				AddWhen(id, when, apply);
			}
			else
			{
				Add(id, apply);
			}
		}

		internal static void Postfix(string id, MethodBase target, global::System.Type holder, string method, Func<bool> when = null)
		{
			Action<Harmony> apply = delegate(Harmony h)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Expected O, but got Unknown
				if (target != (MethodBase)null && !Refused(target))
				{
					h.Patch(target, (HarmonyMethod)null, new HarmonyMethod(holder.GetMethod(method, (BindingFlags)56)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			};
			if (when != null)
			{
				AddWhen(id, when, apply);
			}
			else
			{
				Add(id, apply);
			}
		}

		private static HarmonyMethod Hook(string name)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new HarmonyMethod(typeof(Patches).GetMethod(name, (BindingFlags)40));
		}

		private static void PatchPrefix(Harmony h, MethodBase target, string prefix)
		{
			if (target != (MethodBase)null && !Refused(target))
			{
				h.Patch(target, Hook(prefix), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool Refused(MethodBase target)
		{
			if (!TooSmallToHook(target))
			{
				return false;
			}
			global::System.Type declaringType = ((MemberInfo)target).DeclaringType;
			string text = ((declaringType != null) ? ((MemberInfo)declaringType).Name : null) + "." + ((MemberInfo)target).Name;
			WigglesBW.Log.Warning("Not hooking " + text + ": it's too small to hook safely on Quest.");
			Diagnostics.Report("Hooks", text + " is too small to hook safely, so the feature using it may not work. Everything else is fine.");
			return true;
		}

		private static bool TooSmallToHook(MethodBase target)
		{
			try
			{
				if (!HelperMethods.IsAndroid())
				{
					return false;
				}
				return EndsWithin12Bytes(target);
			}
			catch
			{
				return false;
			}
		}

		[MethodImpl((MethodImplOptions)8)]
		private static bool EndsWithin12Bytes(MethodBase target)
		{
			FieldInfo il2CppMethodInfoPointerFieldForGeneratedMethod = Il2CppInteropUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod(target);
			if (il2CppMethodInfoPointerFieldForGeneratedMethod == (FieldInfo)null)
			{
				return false;
			}
			global::System.IntPtr intPtr = (global::System.IntPtr)il2CppMethodInfoPointerFieldForGeneratedMethod.GetValue((object)null);
			if (intPtr == global::System.IntPtr.Zero)
			{
				return false;
			}
			global::System.IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
			if (intPtr2 == global::System.IntPtr.Zero)
			{
				return false;
			}
			for (int i = 0; i < 3; i++)
			{
				uint num = (uint)Marshal.ReadInt32(intPtr2, i * 4);
				if ((num & 0xFC000000u) == 335544320)
				{
					return true;
				}
				if ((num & 0xFFFFFC1Fu) == 3592355840u)
				{
					return true;
				}
				if ((num & 0xFFFFFC1Fu) == 3596550144u)
				{
					return true;
				}
			}
			return false;
		}

		private static bool WalkPrefix()
		{
			for (int i = 0; i < _walkBlockers.Count; i++)
			{
				try
				{
					if (_walkBlockers[i].Invoke())
					{
						return false;
					}
				}
				catch
				{
				}
			}
			return true;
		}

		private static bool FirePrefix(Gun __instance)
		{
			for (int i = 0; i < _fireFilters.Count; i++)
			{
				try
				{
					if (!_fireFilters[i].Invoke(__instance))
					{
						return false;
					}
				}
				catch
				{
				}
			}
			return true;
		}

		internal static void Update()
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((_queue.Count == 0 && _later.Count == 0) || _harmony == null)
			{
				return;
			}
			if ((Object)(object)Player.Head == (Object)null)
			{
				_nextAt = -1f;
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_nextAt < 0f)
			{
				_nextAt = realtimeSinceStartup + 8f;
				_inLevelSince = realtimeSinceStartup;
			}
			else
			{
				if (realtimeSinceStartup < _nextAt)
				{
					return;
				}
				_nextAt = realtimeSinceStartup + 0.5f;
				if (Time.unscaledDeltaTime > 0.12f && realtimeSinceStartup - _inLevelSince < 40f)
				{
					return;
				}
				if (_queue.Count > 0)
				{
					ValueTuple<string, Action<Harmony>> val = _queue[0];
					string item = val.Item1;
					Action<Harmony> item2 = val.Item2;
					_queue.RemoveAt(0);
					CrashGuard.Stage("hook:" + item);
					Apply(item, item2);
					CrashGuard.Stage((_queue.Count == 0) ? "playing" : ("after hook:" + item));
					return;
				}
				for (int i = 0; i < _later.Count; i++)
				{
					ValueTuple<string, Func<bool>, Action<Harmony>> val2 = _later[i];
					string item3 = val2.Item1;
					Func<bool> item4 = val2.Item2;
					Action<Harmony> item5 = val2.Item3;
					bool flag = false;
					try
					{
						flag = item4.Invoke();
					}
					catch
					{
					}
					if (flag)
					{
						_later.RemoveAt(i);
						CrashGuard.LateHookStart(item3);
						Apply(item3, item5);
						CrashGuard.LateHookDone();
						break;
					}
				}
			}
		}

		private static void Apply(string id, Action<Harmony> apply)
		{
			WigglesBW.Step("hook " + id);
			try
			{
				apply.Invoke(_harmony);
				WigglesBW.Log.Msg("Hook ready: " + id);
			}
			catch (global::System.Exception ex)
			{
				WigglesBW.Log.Warning("Hook " + id + " failed: " + ex.Message);
				Diagnostics.Report("Hooks", $"\"{id}\" couldn't start ({((MemberInfo)ex.GetType()).Name}). That feature may not work; everything else is fine.");
			}
		}
	}
	internal static class Safe
	{
		internal static bool Finite(float f)
		{
			if (!float.IsNaN(f))
			{
				return !float.IsInfinity(f);
			}
			return false;
		}

		internal static bool Finite(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Finite(v.x) && Finite(v.y) && Finite(v.z))
			{
				return ((Vector3)(ref v)).sqrMagnitude < 1E+10f;
			}
			return false;
		}

		internal static void Prepare(params global::System.Type[] types)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			foreach (global::System.Type type in types)
			{
				MethodInfo[] methods = type.GetMethods((BindingFlags)62);
				foreach (MethodInfo val in methods)
				{
					if (!((MethodBase)val).IsAbstract && !((MethodBase)val).ContainsGenericParameters)
					{
						try
						{
							RuntimeHelpers.PrepareMethod(((MethodBase)val).MethodHandle);
						}
						catch
						{
						}
					}
				}
				Prepare(type.GetNestedTypes((BindingFlags)62));
			}
		}
	}
	public abstract class WigglesModule
	{
		public abstract string Name { get; }

		[field: CompilerGenerated]
		public Instance LoggerInstance
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			internal set;
		}

		[field: CompilerGenerated]
		public Harmony HarmonyInstance
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			internal set;
		}

		public static global::System.Collections.Generic.IReadOnlyList<MelonBase> RegisteredMelons => (global::System.Collections.Generic.IReadOnlyList<MelonBase>)MelonBase.RegisteredMelons;

		public virtual void OnInitializeMelon()
		{
		}

		public virtual void OnLateInitializeMelon()
		{
		}

		public virtual void OnUpdate()
		{
		}

		public virtual void OnFixedUpdate()
		{
		}

		public virtual void OnLateUpdate()
		{
		}
	}
	public class WigglesBW : MelonMod
	{
		internal static Instance Log;

		internal const string Title = "Timeline Colliders";

		internal const string Version = "1.7.0";

		private static Page _menu;

		private WigglesModule _clones;

		private bool _off;

		private bool _warned;

		internal static Page Menu => _menu ?? Page.Root;

		internal static void Step(string what)
		{
			try
			{
				Instance log = Log;
				if (log != null)
				{
					log.Msg("[startup] " + what);
				}
			}
			catch
			{
			}
		}

		public override void OnInitializeMelon()
		{
			Log = ((MelonBase)this).LoggerInstance;
			if (PackInstalled())
			{
				_off = true;
				Log.Warning("Wiggles BW is installed and already has this feature: Timeline Colliders stays off. You can delete TimelineColliders.dll.");
				return;
			}
			CrashGuard.Start(((MelonBase)this).Info.Version);
			Patches.Init(((MelonBase)this).HarmonyInstance);
			Diagnostics.CheckStartup((MelonMod)(object)this);
			try
			{
				Hooking.OnLevelLoading += delegate(LevelInfo info)
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					CrashGuard.NoteLevel("loading map " + info.title);
				};
				Hooking.OnLevelLoaded += delegate(LevelInfo info)
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					CrashGuard.NoteLevel("in map " + info.title);
					Diagnostics.OnLevelLoaded();
				};
			}
			catch (global::System.Exception ex)
			{
				Diagnostics.Report("BoneLib", "Couldn't hook level loading (BoneLib version?): " + ex.Message);
			}
			if (!CrashGuard.SafeMode.Value && !CrashGuard.IsOff("module:Timeline Clones"))
			{
				try
				{
					CrashGuard.Stage("module:Timeline Clones");
					_clones = new ClonesMod
					{
						LoggerInstance = ((MelonBase)this).LoggerInstance,
						HarmonyInstance = ((MelonBase)this).HarmonyInstance
					};
					_clones.OnInitializeMelon();
				}
				catch (global::System.Exception ex2)
				{
					_clones = null;
					Log.Error("Couldn't start: " + (object)ex2);
					Diagnostics.Report("Timeline Colliders", "Couldn't start: " + ex2.Message);
				}
				CrashGuard.Stage("starting");
			}
		}

		private bool PackInstalled()
		{
			try
			{
				if (Enumerable.Any<MelonMod>((global::System.Collections.Generic.IEnumerable<MelonMod>)MelonTypeBase<MelonMod>.RegisteredMelons, (Func<MelonMod, bool>)((MelonMod m) => ((MelonBase)m).Info.Name == "Wiggles BW")))
				{
					return true;
				}
				global::System.Collections.Generic.IEnumerator<MelonAssembly> enumerator = MelonAssembly.LoadedAssemblies.GetEnumerator();
				try
				{
					while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
					{
						global::System.Collections.Generic.IEnumerator<MelonBase> enumerator2 = enumerator.Current.LoadedMelons.GetEnumerator();
						try
						{
							while (((global::System.Collections.IEnumerator)enumerator2).MoveNext())
							{
								if (enumerator2.Current.Info.Name == "Wiggles BW")
								{
									return true;
								}
							}
						}
						finally
						{
							((global::System.IDisposable)enumerator2)?.Dispose();
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator)?.Dispose();
				}
			}
			catch
			{
			}
			return false;
		}

		public override void OnLateInitializeMelon()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			if (_off)
			{
				return;
			}
			try
			{
				_menu = Page.Root.CreatePage("Timeline Colliders", new Color(0.9f, 0.25f, 0.2f), 0, true);
			}
			catch (global::System.Exception ex)
			{
				Log.Warning("Menu button failed, the pages go on the main menu: " + ex.Message);
			}
			try
			{
				_clones?.OnLateInitializeMelon();
			}
			catch (global::System.Exception ex2)
			{
				Log.Error("Couldn't finish starting: " + (object)ex2);
				Diagnostics.Report("Timeline Colliders", "Couldn't finish starting: " + ex2.Message);
			}
			CrashGuard.Stage("loading");
			Diagnostics.CreatePage(Menu);
			try
			{
				Menu.CreateBool("Safe Mode (next launch)", new Color(1f, 0.5f, 0.3f), CrashGuard.SafeMode.Value, (Action<bool>)CrashGuard.SetSafeMode);
				if (CrashGuard.AnyOff || CrashGuard.SafeMode.Value)
				{
					Menu.CreateFunction("Turn Everything Back On (next launch)", new Color(0.5f, 1f, 0.5f), new Action(CrashGuard.TurnEverythingBackOn));
				}
			}
			catch
			{
			}
		}

		private void Call(Action<WigglesModule> call)
		{
			if (_clones == null)
			{
				return;
			}
			try
			{
				call.Invoke(_clones);
			}
			catch (global::System.Exception ex)
			{
				if (!_warned)
				{
					_warned = true;
					Log.Error("Error while playing: " + (object)ex);
					Diagnostics.Report("Timeline Colliders", "Error while playing: " + ((MemberInfo)ex.GetType()).Name + ": " + ex.Message);
				}
			}
		}

		public override void OnUpdate()
		{
			if (_off)
			{
				return;
			}
			Call(delegate(WigglesModule m)
			{
				m.OnUpdate();
			});
			try
			{
				Patches.Update();
			}
			catch
			{
			}
			try
			{
				Diagnostics.Update();
			}
			catch
			{
			}
			try
			{
				CrashGuard.Update();
			}
			catch
			{
			}
		}

		public override void OnFixedUpdate()
		{
			if (!_off)
			{
				Call(delegate(WigglesModule m)
				{
					m.OnFixedUpdate();
				});
			}
		}

		public override void OnLateUpdate()
		{
			if (!_off)
			{
				Call(delegate(WigglesModule m)
				{
					m.OnLateUpdate();
				});
			}
		}

		public override void OnApplicationQuit()
		{
			try
			{
				if (!_off)
				{
					CrashGuard.CleanExit();
				}
			}
			catch
			{
			}
		}
	}
}
namespace TimelineClones
{
	internal static class BloodFx
	{
		private const int PoolSize = 64;

		private static Transform _root;

		private static ParticleSystem _drops;

		private static ParticleSystem _mist;

		private static Transform[] _pool;

		private static MeshRenderer[] _poolRenderers;

		private static int _next;

		private static Material[] _splatMats;

		private static Il2CppStructArray<RaycastHit> _hits;

		private static readonly Color Arterial = new Color(0.3f, 0.012f, 0.012f, 1f);

		private static readonly Color Venous = new Color(0.12f, 0.004f, 0.006f, 1f);

		internal static bool Replaying;

		internal static void EnsureBuilt()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Expected O, but got Unknown
			//IL_008c: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00ee: Expected O, but got Unknown
			//IL_00ee: Expected O, but got Unknown
			if (!((Object)(object)_drops != (Object)null))
			{
				GameObject val = new GameObject("TimelineClones_Blood");
				Object.DontDestroyOnLoad((Object)val);
				_root = val.transform;
				_drops = MakeParticles("Droplets", 800, new MinMaxCurve(0.6f, 1.3f), new MinMaxCurve(0.006f, 0.022f), 1.6f, new MinMaxGradient(Venous, Arterial), Dot(16, 0.9f), stretch: true);
				_mist = MakeParticles("Mist", 120, new MinMaxCurve(0.12f, 0.3f), new MinMaxCurve(0.05f, 0.14f), 0.05f, new MinMaxGradient(new Color(0.28f, 0.02f, 0.02f, 0.35f), new Color(0.16f, 0.01f, 0.01f, 0.2f)), Dot(32, 0.5f), stretch: false);
				_splatMats = (Material[])(object)new Material[4];
				for (int i = 0; i < _splatMats.Length; i++)
				{
					_splatMats[i] = Unlit(SplatTexture(128, i), 3040);
				}
				_pool = (Transform[])(object)new Transform[64];
				_poolRenderers = (MeshRenderer[])(object)new MeshRenderer[64];
				for (int j = 0; j < 64; j++)
				{
					GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)5);
					((Object)val2).name = "BloodSplat";
					Object.Destroy((Object)(object)val2.GetComponent<Collider>());
					MeshRenderer component = val2.GetComponent<MeshRenderer>();
					((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
					((Renderer)component).receiveShadows = false;
					val2.transform.SetParent(_root, false);
					val2.SetActive(false);
					_pool[j] = val2.transform;
					_poolRenderers[j] = component;
				}
			}
		}

		internal static void Warm(Vector3 at)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0048: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			EnsureBuilt();
			EmitParams val = default(EmitParams);
			((EmitParams)(ref val)).applyShapeToPosition = false;
			((EmitParams)(ref val)).position = at;
			((EmitParams)(ref val)).velocity = Vector3.zero;
			((EmitParams)(ref val)).startSize = 0.0005f;
			((EmitParams)(ref val)).startLifetime = 0.1f;
			EmitParams val2 = val;
			_drops.Emit(val2, 1);
			_mist.Emit(val2, 1);
			Material[] splatMats = _splatMats;
			foreach (Material sharedMaterial in splatMats)
			{
				GameObject obj = GameObject.CreatePrimitive((PrimitiveType)5);
				Object.Destroy((Object)(object)obj.GetComponent<Collider>());
				((Renderer)obj.GetComponent<MeshRenderer>()).sharedMaterial = sharedMaterial;
				obj.transform.position = at;
				obj.transform.localScale = Vector3.one * 0.0005f;
				Object.Destroy((Object)(object)obj, 0.3f);
			}
			Replaying = true;
			try
			{
				Vector3 point = at + Vector3.down * 3000f;
				Hit(point, Vector3.down, Vector3.up, 1f);
				Stream(point, Vector3.down, 0.5f);
			}
			finally
			{
				Replaying = false;
			}
			if (CastSurface(at, Vector3.down, 5f, out var best))
			{
				PlaceSplat(best, Vector3.down, 0.0005f, 0);
				((Component)_pool[(_next + 64 - 1) % 64]).gameObject.SetActive(false);
			}
		}

		internal static void Stream(Vector3 point, Vector3 dir, float pressure)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (ClonesMod.Blood.Value && !(pressure <= 0f))
			{
				if (!Replaying)
				{
					ClonesMod.OnBlood(point, dir, Vector3.up, 0f - pressure);
				}
				EmitStream(point, dir, pressure);
			}
		}

		private static void EmitStream(Vector3 point, Vector3 dir, float pressure)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_007f: 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_008a: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00cc: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_0143: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			EnsureBuilt();
			pressure = Mathf.Clamp01(pressure);
			dir = ((((Vector3)(ref dir)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref dir)).normalized : Vector3.down);
			EmitParams val = default(EmitParams);
			((EmitParams)(ref val)).applyShapeToPosition = false;
			EmitParams val2 = val;
			int num = Mathf.Clamp(Mathf.RoundToInt((2f + 10f * pressure) * ClonesMod.BloodAmount.Value), 1, 24);
			float num2 = Mathf.Lerp(0.3f, 0.07f, pressure);
			for (int i = 0; i < num; i++)
			{
				((EmitParams)(ref val2)).position = point + Random.insideUnitSphere * 0.008f;
				Vector3 val3 = dir + Random.insideUnitSphere * num2;
				((EmitParams)(ref val2)).velocity = ((Vector3)(ref val3)).normalized * (Random.Range(2.6f, 4.2f) * pressure + 0.15f);
				((EmitParams)(ref val2)).startSize = Random.Range(0.007f, 0.02f) * (0.7f + pressure * 0.5f);
				_drops.Emit(val2, 1);
			}
			if (!(Random.value > 0.3f + pressure * 0.2f))
			{
				Vector3 val4 = Vector3.ProjectOnPlane(dir, Vector3.up) * (pressure * 1.1f);
				if (CastSurface(point + val4 + new Vector3(Random.Range(-0.06f, 0.06f), 0f, Random.Range(-0.06f, 0.06f)) + Vector3.up * 0.2f, Vector3.down, 3f, out var best))
				{
					PlaceSplat(best, Vector3.down, Random.Range(0.08f, 0.2f), (!(Random.value < 0.6f)) ? 3 : 0);
				}
			}
		}

		internal static void Hit(Vector3 point, Vector3 dir, Vector3 surfaceNormal, float amount)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_003d: 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_007e: 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_0083: 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_0093: 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_00a2: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: 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_00db: 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_00dc: 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_01bb: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_00fb: 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_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: 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_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			if (amount > 0f)
			{
				try
				{
					Scars.Add(point, dir, surfaceNormal, amount);
				}
				catch
				{
				}
			}
			if (!ClonesMod.Blood.Value)
			{
				return;
			}
			if (amount < 0f)
			{
				EmitStream(point, dir, 0f - amount);
				return;
			}
			if (!Replaying)
			{
				ClonesMod.OnBlood(point, dir, surfaceNormal, amount);
			}
			EnsureBuilt();
			amount = Mathf.Clamp(amount * ClonesMod.BloodAmount.Value, 0.2f, 3f);
			dir = ((((Vector3)(ref dir)).sqrMagnitude > 1E-06f) ? ((Vector3)(ref dir)).normalized : Vector3.down);
			Vector3 val = ((((Vector3)(ref surfaceNormal)).sqrMagnitude > 0.01f) ? ((Vector3)(ref surfaceNormal)).normalized : (-dir));
			EmitParams val2 = default(EmitParams);
			((EmitParams)(ref val2)).applyShapeToPosition = false;
			EmitParams val3 = val2;
			int num = Mathf.RoundToInt(22f * amount);
			Vector3 val4;
			for (int i = 0; i < num; i++)
			{
				bool flag = i % 4 == 0;
				val4 = (flag ? val : dir) + Random.insideUnitSphere * (flag ? 0.5f : 0.35f);
				Vector3 velocity = ((Vector3)(ref val4)).normalized * Random.Range(1.5f, flag ? 3f : 6f);
				((EmitParams)(ref val3)).position = point + Random.insideUnitSphere * 0.015f;
				((EmitParams)(ref val3)).velocity = velocity;
				((EmitParams)(ref val3)).startSize = Random.Range(0.006f, 0.022f) * (flag ? 0.8f : 1f);
				_drops.Emit(val3, 1);
			}
			val2 = default(EmitParams);
			((EmitParams)(ref val2)).applyShapeToPosition = false;
			EmitParams val5 = val2;
			int num2 = Mathf.RoundToInt(5f * amount);
			for (int j = 0; j < num2; j++)
			{
				((EmitParams)(ref val5)).position = point;
				((EmitParams)(ref val5)).velocity = (val * 0.6f + dir * 0.4f + Random.insideUnitSphere * 0.5f) * Random.Range(0.3f, 1.2f);
				_mist.Emit(val5, 1);
			}
			int num3 = Mathf.Clamp(Mathf.RoundToInt(3f * amount), 1, 6);
			for (int k = 0; k < num3; k++)
			{
				val4 = dir + Random.insideUnitSphere * ((k == 0) ? 0.05f : 0.3f);
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				if (CastSurface(point + normalized * 0.1f, normalized, 3f, out var best))
				{
					float size = ((k == 0) ? Random.Range(0.18f, 0.32f) : Random.Range(0.06f, 0.16f)) * Mathf.Sqrt(amount);
					PlaceSplat(best, normalized, size, (k != 0) ? 1 : Random.Range(0, 2));
				}
			}
			int num4 = Mathf.Clamp(Mathf.RoundToInt(2f * amount), 1, 4);
			for (int l = 0; l < num4; l++)
			{
				if (CastSurface(point + new Vector3(Random.Range(-0.25f, 0.25f), 0f, Random.Range(-0.25f, 0.25f)), Vector3.down, 3f, out var best2))
				{
					PlaceSplat(best2, Vector3.down, Random.Range(0.04f, 0.1f), 3);
				}
			}
		}

		internal static void Clear()
		{
			if (_pool == null)
			{
				return;
			}
			Transform[] pool = _pool;
			foreach (Transform val in pool)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			if ((Object)(object)_drops != (Object)null)
			{
				_drops.Clear();
			}
			if ((Object)(object)_mist != (Object)null)
			{
				_mist.Clear();
			}
		}

		private static void PlaceSplat(RaycastHit hit, Vector3 travel, float size, int variant)
		{
			//IL_0084: 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_008a: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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)
			//IL_010c: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: 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)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: 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)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			int next = _next;
			_next = (_next + 1) % 64;
			Transform val = _pool[next];
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)5);
				((Object)val2).name = "BloodSplat";
				Object.Destroy((Object)(object)val2.GetComponent<Collider>());
				_poolRenderers[next] = val2.GetComponent<MeshRenderer>();
				((Renderer)_poolRenderers[next]).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)_poolRenderers[next]).receiveShadows = false;
				val = (_pool[next] = val2.transform);
			}
			Vector3 normal = ((RaycastHit)(ref hit)).normal;
			Vector3 val3 = Vector3.ProjectOnPlane(travel, normal);
			float magnitude = ((Vector3)(ref val3)).magnitude;
			bool flag = magnitude > 0.55f;
			if (flag)
			{
				variant = 2;
			}
			Rigidbody attachedRigidbody = ((RaycastHit)(ref hit)).collider.attachedRigidbody;
			val.SetParent(((Object)(object)attachedRigidbody != (Object)null) ? ((Component)((RaycastHit)(ref hit)).collider).transform : _root, true);
			((Component)val).gameObject.SetActive(true);
			((Renderer)_poolRenderers[next]).sharedMaterial = _splatMats[variant];
			val.position = ((RaycastHit)(ref hit)).point + normal * 0.004f;
			Vector3 val4;
			Vector3 normalized;
			if (!(magnitude > 0.05f))
			{
				val4 = Vector3.ProjectOnPlane(Random.onUnitSphere, normal);
				normalized = ((Vector3)(ref val4)).normalized;
			}
			else
			{
				normalized = ((Vector3)(ref val3)).normalized;
			}
			Vector3 val5 = normalized;
			if (((Vector3)(ref val5)).sqrMagnitude < 0.01f)
			{
				val4 = Vector3.ProjectOnPlane(Vector3.up, normal);
				val5 = ((Vector3)(ref val4)).normalized;
			}
			if (((Vector3)(ref val5)).sqrMagnitude < 0.01f)
			{
				val5 = Vector3.forward;
			}
			val.rotation = Quaternion.LookRotation(-normal, val5);
			float num = (flag ? Mathf.Lerp(1.6f, 3f, magnitude) : 1f);
			Vector3 val6 = (((Object)(object)val.parent != (Object)null) ? val.parent.lossyScale : Vector3.one);
			float num2 = 1f / Mathf.Max(Mathf.Abs(val6.x), 0.0001f);
			val.localScale = new Vector3(size * (flag ? 0.6f : 1f), size * num, 1f) * num2;
		}

		private static bool CastSurface(Vector3 origin, Vector3 dir, float dist, out RaycastHit best)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			best = default(RaycastHit);
			if (_hits == null)
			{
				_hits = new Il2CppStructArray<RaycastHit>(12L);
			}
			int num = Physics.RaycastNonAlloc(origin, dir, _hits, dist, -5, (QueryTriggerInteraction)1);
			float num2 = 3.4028235E+38f;
			bool result = false;
			RigManager rigManager = Player.RigManager;
			for (int i = 0; i < num; i++)
			{
				RaycastHit val = ((Il2CppArrayBase<RaycastHit>)(object)_hits)[i];
				Collider collider = ((RaycastHit)(ref val)).collider;
				if (!((Object)(object)collider == (Object)null) && !(((RaycastHit)(ref val)).distance >= num2) && ((Component)collider).gameObject.layer != 12 && (!((Object)(object)rigManager != (Object)null) || !((Object)(object)((Component)collider).GetComponentInParent<RigManager>() == (Object)(object)rigManager)))
				{
					num2 = ((RaycastHit)(ref val)).distance;
					best = val;
					result = true;
				}
			}
			return result;
		}

		private static ParticleSystem MakeParticles(string name, int max, MinMaxCurve life, MinMaxCurve size, float gravity, MinMaxGradient color, Texture2D tex, bool stretch)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(_root, false);
			ParticleSystem obj = val.AddComponent<ParticleSystem>();
			obj.Stop(true, (ParticleSystemStopBehavior)0);
			MainModule main = obj.main;
			main.loop = false;
			main.playOnAwake = false;
			main.maxParticles = max;
			main.simulationSpace = (ParticleSystemSimulationSpace)1;
			main.startLifetime = life;
			main.startSize = size;
			main.startSpeed = new MinMaxCurve(0f);
			main.gravityModifier = new MinMaxCurve(gravity);
			main.startColor = color;
			obj.emission.enabled = false;
			ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
			((Renderer)component).sharedMaterial = Unlit(tex, 3050);
			((Renderer)component).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)component).receiveShadows = false;
			if (stretch)
			{
				component.renderMode = (ParticleSystemRenderMode)1;
				component.velocityScale = 0.035f;
				component.lengthScale = 1.2f;
			}
			return obj;
		}

		private static Material Unlit(Texture2D tex, int queue)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(Shader.Find("UI/Default") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Universal Render Pipeline/Unlit"))
			{
				hideFlags = (HideFlags)32,
				renderQueue = queue
			};
			if (val.HasProperty("_MainTex"))
			{
				val.SetTexture("_MainTex", (Texture)(object)tex);
			}
			if (val.HasProperty("_BaseMap"))
			{
				val.SetTexture("_BaseMap", (Texture)(object)tex);
			}
			if (val.HasProperty("_Color"))
			{
				val.SetColor("_Color", Color.white);
			}
			return val;
		}

		private static Texture2D Dot(int size, float hardness)
		{
			//IL_0077: 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)
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float num = (float)(size - 1) * 0.5f;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num2 = Mathf.Sqrt(((float)j - num) * ((float)j - num) + ((float)i - num) * ((float)i - num)) / num;
					float num3 = Mathf.Clamp01((1f - num2) / Mathf.Max(1f - hardness, 0.05f));
					array[i * size + j] = new Color32((byte)255, (byte)255, (byte)255, (byte)(num3 * 255f));
				}
			}
			return Upload(array, size);
		}

		private static Texture2D SplatTexture(int size, int variant)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: 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_0120: 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_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_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: 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_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			Color32[] array = (Color32[])(object)new Color32[size * size];
			float num = (float)(size - 1) * 0.5f;
			uint seed = (uint)(9000 + variant * 7919);
			float[] array2 = new float[8];
			float[] array3 = new float[8];
			for (int i = 0; i < 8; i++)
			{
				array2[i] = (0.05f + Rand() * 0.07f) / (1f + (float)i * 0.6f);
				array3[i] = Rand() * (float)Math.PI * 2f;
			}
			Vector3[] array4 = (Vector3[])(object)new Vector3[variant switch
			{
				2 => 10, 
				1 => 18, 
				_ => 0, 
			}];
			for (int j = 0; j < array4.Length; j++)
			{
				float num2 = Rand() * (float)Math.PI * 2f;
				float num3 = 0.55f + Rand() * 0.4f;
				Vector2 val = ((variant == 2) ? new Vector2((Rand() - 0.5f) * 0.2f, 0.62f + Rand() * 0.33f) : new Vector2(Mathf.Cos(num2) * num3, Mathf.Sin(num2) * num3));
				array4[j] = new Vector3(val.x, val.y, 0.025f + Rand() * ((variant == 2) ? 0.05f : 0.06f));
			}
			for (int k = 0; k < size; k++)
			{
				for (int l = 0; l < size; l++)
				{
					float num4 = ((float)l - num) / num;
					float num5 = ((float)k - num) / num;
					float num13;
					if (variant == 2)
					{
						float num6 = Mathf.Atan2(num5 + 0.35f, num4);
						float num7 = 0.38f + 0.04f * Mathf.Sin(num6 * 3f + array3[0]) + 0.025f * Mathf.Sin(num6 * 7f + array3[1]);
						float num8 = Mathf.Sqrt(num4 * num4 + (num5 + 0.35f) * (num5 + 0.35f)) / num7;
						float num9 = Mathf.InverseLerp(-0.35f, 0.6f, num5);
						float num10 = Mathf.Lerp(0.3f, 0.015f, Mathf.Sqrt(num9));
						float num11 = 0.02f * Mathf.Sin(num5 * 9f + array3[2]);
						float num12 = ((num5 > -0.35f && num5 < 0.6f) ? (Mathf.Abs(num4 - num11) / num10) : 9f);
						num13 = Mathf.Clamp01((1f - Mathf.Min(num8, num12)) * 5f);
					}
					else
					{
						float num14 = Mathf.Sqrt(num4 * num4 + num5 * num5);
						float num15 = Mathf.Atan2(num5, num4);
						float num16 = variant switch
						{
							1 => 0.36f, 
							3 => 0.42f, 
							_ => 0.6f, 
						};
						for (int m = 0; m < 8; m++)
						{
							num16 += array2[m] * Mathf.Sin(num15 * (float)(m + 2) + array3[m]);
						}
						if (variant == 1)
						{
							num16 += 0.18f * Mathf.Pow(Mathf.Max(0f, Mathf.Sin(num15 * 3f + array3[3]) * Mathf.Sin(num15 * 5f + array3[4])), 6f);
						}
						num13 = Mathf.Clamp01((num16 - num14) * 12f);
					}
					Vector3[] array5 = array4;
					foreach (Vector3 val2 in array5)
					{
						float num17 = Mathf.Sqrt((num4 - val2.x) * (num4 - val2.x) + (num5 - val2.y) * (num5 - val2.y));
						num13 = Mathf.Max(num13, Mathf.Clamp01((val2.z - num17) * 60f));
					}
					float num18 = Mathf.Sqrt(num4 * num4 + num5 * num5);
					float num19 = Mathf.Clamp01(1f - num18 * 1.3f);
					float num20 = Mathf.PerlinNoise((float)l * 0.09f + (float)variant * 3f, (float)k * 0.09f);
					float num21 = Mathf.Lerp(34f, 80f, num19 * 0.7f + num20 * 0.3f);
					array[k * size + l] = new Color32((byte)num21, (byte)(num21 * 0.04f), (byte)(num21 * 0.04f), (byte)(num13 * 240f));
				}
			}
			return Upload(array, size);
			[CompilerGenerated]
			float Rand()
			{
				seed = seed * 1664525 + 1013904223;
				return (float)(seed >> 8) / 16777216f;
			}
		}

		private static Texture2D Upload(Color32[] px, int size)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, true)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1,
				hideFlags = (HideFlags)32
			};
			val.SetPixels32(Il2CppStructArray<Color32>.op_Implicit(px), 0);
			val.Apply(true, true);
			return val;
		}
	}
	public enum BonePart
	{
		LeftArm,
		RightArm,
		LeftLeg,
		RightLeg
	}
	internal static class BrokenBones
	{
		private class Entry
		{
			public Animator Anim;

			public int Part;

			public float Until;

			public float IgnoreUntil;

			public Transform Upper;

			public Vector3 JointLocal;

			public GoreKit.Cut Cut;

			public Rigidbody Anchor;

			public GameObject Shard;

			public Action<Collider> Ignore;
		}

		internal const int NetFlag = 32;

		private const float IgnoreFor = 2f;

		private const float TwistLimit = 60f;

		private const float SwingLimit = 150f;

		private static readonly List<Entry> _all = new List<Entry>();

		private static int _frame = -1;

		private static float _fixedAt = -1f;

		private static Mesh _shardMesh;

		private static Material _shardMat;

		internal static int PartOf(BonePart p)
		{
			return p switch
			{
				BonePart.LeftArm => 4, 
				BonePart.RightArm => 6, 
				BonePart.LeftLeg => 8, 
				_ => 10, 
			};
		}

		internal static int Lower(int part)
		{
			if (part % 2 != 1)
			{
				return part;
			}
			return part + 1;
		}

		internal static bool Has(Animator anim, int part)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<Entry> enumerator = _all.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Entry current = enumerator.Current;
					if ((Object)(object)current.Anim == (Object)(object)anim && current.Part == part)
					{
						return true;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			return false;
		}

		internal static Action<Collider> IgnoreAll(Component root)
		{
			return delegate(Collider col)
			{
				if ((Object)(object)root == (Object)null || (Object)(object)col == (Object)null)
				{
					return;
				}
				global::System.Collections.Generic.IEnumerator<Collider> enumerator = root.GetComponentsInChildren<Collider>(false).GetEnumerator();
				try
				{
					while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
					{
						Collider current = enumerator.Current;
						if ((Object)(object)current != (Object)null)
						{
							Physics.IgnoreCollision(col, current, true);
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator)?.Dispose();
				}
			};
		}

		private static HumanBodyBones EndOf(int part)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			return (HumanBodyBones)(part switch
			{
				4 => 17, 
				6 => 18, 
				8 => 5, 
				_ => 6, 
			});
		}

		internal static void Bend(Avatar avatar, int part, float seconds, ushort owner = 0, Action<Collider> ignore = null)
		{
			//IL_0061: 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_0076: 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_0082: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00c0: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_016d: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: 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_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: 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_02cc: Unknown result type (might be due to invalid IL or missing references)
			Animator val = (((Object)(object)avatar != (Object)null) ? avatar.animator : null);
			if ((Object)(object)val == (Object)null || !val.isHuman || Has(val, part))
			{
				return;
			}
			Transform boneTransform = val.GetBoneTransform(RagdollDrag.Bones[part - 1]);
			Transform boneTransform2 = val.GetBoneTransform(RagdollDrag.Bones[part]);
			if ((Object)(object)boneTransform == (Object)null || (Object)(object)boneTransform2 == (Object)null)
			{
				return;
			}
			Transform boneTransform3 = val.GetBoneTransform(EndOf(part));
			Vector3 val2 = (((Object)(object)boneTransform3 != (Object)null) ? boneTransform3.position : (boneTransform2.position + (boneTransform2.position - boneTransform.position))) - boneTransform2.position;
			Vector3 val3;
			Vector3 normalized;
			if (!(((Vector3)(ref val2)).sqrMagnitude > 1E-08f))
			{
				val3 = boneTransform2.position - boneTransform.position;
				normalized = ((Vector3)(ref val3)).normalized;
			}
			else
			{
				normalized = ((Vector3)(ref val2)).normalized;
			}
			Vector3 val4 = normalized;
			val3 = boneTransform2.position - boneTransform.position;
			float num = Mathf.Clamp(((Vector3)(ref val3)).magnitude / 0.28f, 0.3f, 4f);
			Vector3 val5 = Vector3.ProjectOnPlane(Front(val), val4);
			Vector3 normalized2;
			if (!(((Vector3)(ref val5)).sqrMagnitude > 1E-08f))
			{
				val3 = Vector3.Cross(val4, Vector3.up);
				normalized2 = ((Vector3)(ref val3)).normalized;
			}
			else
			{
				normalized2 = ((Vector3)(ref val5)).normalized;
			}
			val5 = normalized2;
			Vector3 at = boneTransform2.position + val2 * 0.22f + val5 * (0.03f * num);
			val3 = val5 * 0.85f + val4 * 0.5f;
			Quaternion rotation = Quaternion.LookRotation(((Vector3)(ref val3)).normalized, val4);
			Entry entry